home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games: Greatest Hits 1996 / Amiga Games: Greatest Hits 1996.iso / userbox / publicdomain / time_guide / source / t_bestellen.c next >
C/C++ Source or Header  |  1996-02-23  |  78KB  |  2,607 lines
  1. /*********************************************************
  2.  * Time Disk Bestellungsprogramm für die Time.guide        *
  3.  *                (Mein allererstes C Programm)                        *
  4.  *********************************************************
  5.  * Autor:                    Manfred Tremmel                        *
  6.  * Programmiersprache:    C                                            *
  7.  * Compilier:                Maxon C++ (ANSI-C-Modus)            *
  8.  *********************************************************/
  9.  
  10. /* Versionsstring festlegen (fürs Shellkomando Version)    */ 
  11. char VersionID[] = "$VER: T_Bestellen 1.58 (23.02.96)";
  12.  
  13. /* C-Include für String-Operationen                                */
  14. #include <string.h>
  15. #include <stdlib.h>
  16. /* C-Include für Dateioperationen (laden, speichern)        */
  17. #include <stdio.h>
  18.  
  19. /* AMIGA-Includes für die Exec.library                            */
  20. #include <clib/exec_protos.h>
  21. #include <exec/memory.h>
  22. /* AMIGA-Include für die AmigaGuide.library                    */
  23. #include <clib/amigaguide_protos.h>
  24. /* AMIGA-Include für die graphics.library                        */
  25. #include <clib/graphics_protos.h>
  26. /* AMIGA-Include für die intuition.library                    */
  27. #include <clib/intuition_protos.h>
  28. /* AMIGA-Include für die gadtools.library                        */
  29. #include <clib/gadtools_protos.h>
  30. /* AMIGA-Include für die asl.library                            */
  31. #include <clib/asl_protos.h>
  32. /* AMIGA-Include für die locale.library                        */
  33. #include <clib/locale_protos.h>
  34. /* AMIGA-Include für die icon.library                            */
  35. #include <clib/icon_protos.h>
  36. /* AMIGA-Include für die commodities.library                    */
  37. #include <clib/commodities_protos.h>
  38. #include <clib/alib_protos.h>
  39. /* AMIGA-Include für die dos.library zur Dateiüberwachung*/
  40. #include <dos/notify.h>
  41.  
  42. /* AMIGA-Include, das die ganzen pragma/#? included        */
  43. #include <pragma/all_lib.h>
  44.  
  45. /* AMIGA-Include, daß das Programm WB-Startfähig macht    */
  46. #include <workbench/startup.h>
  47. #include <wbstartup.h>
  48.  
  49. /* Texte, die der User zu Gesicht kriegt (via Local-lib.)*/
  50. #include "T_Locale.h"
  51.  
  52. /* Structur für die Intuition.library                            */
  53. struct IntuitionBase    *IntuitionBase        = NULL;
  54. /* Structur für die graphics.library                            */
  55. struct GfxBase            *GfxBase                = NULL;
  56. /* Structur für die gadtools.library                            */
  57. struct Library            *GadToolsBase        = NULL;
  58. /* Structur für die AmigaGuide.library                            */
  59. struct Library            *AmigaGuideBase    = NULL;
  60. /* Structur für die Asl.library                                    */
  61. struct Library            *AslBase                = NULL;
  62. /* Structur für die locale.library                                */
  63. struct LocaleBase        *LocaleBase            = NULL;
  64. /* Structur für die icon.library                                    */
  65. struct IconBase        *IconBase            = NULL;
  66. /* Structur für die commodities.library                        */
  67. struct CxBase            *CxBase                = NULL;
  68. CxObj    *broker, *filter, *sender, *translate;
  69. #define EVT_HOTKEY 1L
  70.  
  71. /* Notify-Structur zur Überwachung der Disk-Datei            */
  72. struct NotifyRequest    *nr;
  73. struct MsgPort            *nmp;
  74. struct NotifyMessage    *nm;
  75.  
  76. /* Signal-Flag-Variablen für die Abfrag eingehender        */
  77. /* Nachrichten (Window und Commodity)                            */
  78. ULONG wndsigflag, cxsigflag;
  79.  
  80. /* Structur für den Asl-Filerequester                            */
  81. struct FileRequester    *fr;
  82. /* Structur für einen einfachen Info-Requester                */
  83. struct EasyStruct        es;
  84.  
  85. /* Dient dazu, eine neue Liste anzulegen                        */
  86. void NewList(struct List *);
  87.  
  88. /* OS 3.x indikator NOS (New Operating System)                */
  89. BOOL NOS = TRUE;
  90. /* Anzahl sichtbarer Einträge im Listview-Gadget            */
  91. /* Unter OS 2.x sind es nur 11 unter 3.x 12 Einträge     */
  92. int  LVSicht = 12;
  93.  
  94. /* Globale Variablen definieren                                    */
  95. /* Einstellungen:                                                        */
  96. struct Einst {
  97.     char AName[30];            /* Absender:    Name                */
  98.     char AStrasse[30];        /* Absender:    Straße            */
  99.     char AOrt[30];                /* Absender:    Ort                */
  100.     char EName[30];            /* Empfänger:    Name                */    
  101.     char EStrasse[30];        /* Empfänger:    Straße            */
  102.     char EOrt[30];                /* Empfänger:    Ort                */
  103.     long Abstand;                /* Druckbeginnabstand            */
  104.     UWORD Versart;                /* Versandart                        */
  105.     char KundNr[30];            /* Absender:    Kundennummer    */
  106. };
  107.  
  108. struct Einst P1;                /* Konkrete Strukt. festlegen    */
  109.  
  110. /* Struktur der Diskettenliste (nur der Diskettenname)    */
  111. struct VDB{
  112.     char Name[16];                /* Diskettennamen                    */
  113. };
  114.  
  115. /* Structur zur Verwaltung der Diskettenliste anlegen        */
  116. struct VDBnode{
  117.     struct    Node n;
  118.     struct    VDB  d;
  119. };
  120.  
  121. /* erzeugt eine Liste, in die die einzelen VDBs kommen    */
  122. struct List vdblist;
  123.  
  124. /* vdblist enthält den aktuellen Eintrag oder NULL            */
  125. struct VDBnode *currentvdb;
  126.  
  127. /* Dateiname des Einstellungs-Files                                */
  128. char Einst_File[128] = "T_Best.dat";
  129.  
  130. /* Datei zwischengemerkter Disketten                            */
  131. char T_Remember[128] = "T:Time_Remember.dat";
  132.  
  133. /* Variablen für das Einbinden als Commodity                    */
  134. BYTE CX_Priority = 0;
  135. BOOL CX_Popup = TRUE;
  136. char CX_Popkey[30] = "ctrl alt t";
  137.  
  138. /* Titel des Fensters                                                */
  139. char WinTitel[50];
  140. /* Funktion GetString holt einen Text aus dem Puffer        */
  141. #define GetString( g )    ((( struct StringInfo * )g->SpecialInfo )->Buffer  )
  142. /* Funktion GetNumber holt eine Nummer aus dem Puffer        */
  143. #define GetNumber( g )    ((( struct StringInfo * )g->SpecialInfo )->LongInt )
  144.  
  145. /* Die Nummern der Gadgets mit konkreten Bezeichnung        */
  146. #define GD_Diskliste        0        /* Diskettenliste                */
  147. #define GD_NeueDisk        1        /* Neu Button                    */
  148. #define GD_DiskLoeschen    2        /* Löschen Button                */
  149. #define GD_Zahlart        3        /* Zahlart MX-Button            */
  150. #define GD_Drucken        4        /* Drucken Button                */
  151. #define GD_Abbrechen        5        /* Abbrechen Button            */
  152. #define GD_AName            6        /* Absender: Name                */
  153. #define GD_AStrasse        7        /* Absender: Strasse            */
  154. #define GD_AOrt            8        /* Absender: Ort                */
  155. #define GD_KundNr            9        /* Kundennummer                */
  156. #define GD_EName            10        /* Empfänger: Name            */
  157. #define GD_EStrasse        11        /* Empfänger: Strasse        */
  158. #define GD_EOrt            12        /* Empfänger: Ort                */
  159. #define GD_DiskAender    13        /* Disk ändern                    */
  160. #define GD_Abstand        14        /* Abstand zum Druckbeginn    */
  161.  
  162. /* Anzahl der Gadgets definieren (0 bis 14 = 15)            */
  163. #define Bestellen_CNT                                    15
  164.  
  165. /* Die Nummern der Menus mit Konkreten Bezeichnungen        */
  166. #define MENU_FOO_OPA        1        /* Öffnen - Einstellungen    */
  167. #define MENU_FOO_OPB        2        /* Öffnen - Diskliste        */
  168. #define MENU_FOO_SPA        3        /* Speichern - Einstell.    */
  169. #define MENU_FOO_SPB        4        /* Speichern - Diskliste    */
  170. #define MENU_FOO_SAA        5        /* Speichern als -Einstell.*/
  171. #define MENU_FOO_SAB        6        /* Speichern als -Diskliste*/
  172. #define MENU_FOO_DRU        7        /* Drucken                        */
  173. #define MENU_FOO_INF        8        /* Information                    */
  174. #define MENU_FOO_HID        9        /* Verbergen                    */
  175. #define MENU_FOO_END        10        /* Ende                            */    
  176.  
  177. /* Screenstruktur löschen                                            */
  178. struct Screen            *Scr = NULL;
  179. /* Public Screen Name löschen                                        */
  180. UBYTE                        *PubScreenName = NULL;
  181. /* DrawInfo deklarieren und löschen                                */
  182. struct DrawInfo        *dri = NULL;
  183. /* VisualInfo löschen                                                */
  184. APTR                        VisualInfo = NULL;
  185. /* Window Struktur löschen                                            */
  186. struct Window            *BestellenWnd = NULL;
  187. /* Gadget Struktur löschen                                            */
  188. struct Gadget            *BestellenGList = NULL;
  189. /* Menu Struktur löschen                                            */
  190. struct Menu                *BestellenMenus = NULL;
  191. /* NewBroker Structur (zur Einbindung als Commodity)        */
  192. struct NewBroker        newbroker = {NULL, NULL, NULL, NULL,
  193.                                     NULL, NULL, NULL, NULL, NULL};
  194.  
  195. /* Anzahl GadgetStrukturen festlegen (15)                        */
  196. struct Gadget            *BestellenGadgets[15];
  197. /* Breite des Fensters (wird nach Fontbreite umgerechnet)*/
  198. UWORD                        BestellenWidth = 460;
  199. /* Höhe des Fenster (wird nach Fonthöhe umgerechnet)        */
  200. UWORD                        BestellenHeight = 250;
  201. /* Struktur Textatribute mit Fontinformationen definieren*/
  202. struct TextAttr        *Font, Attr;
  203. /* Definiere Felder für die Fontbreite und Höhe                */
  204. UWORD                        FontX, FontY;
  205. /* Definiere Felder für den minimalabstand des Fensters    */
  206. UWORD                        OffX, OffY;
  207. /* Definiere Felder für tatsächliche Pos. des Fensters    */
  208. UWORD                        WinX = 0;
  209. UWORD                        WinY = 0;
  210. /* Position im Listview-Gadget                                    */
  211. long                        ListPos = 0;
  212.  
  213. /* Textatribrute für das Fenster                                    */
  214. struct TextFont        *BestellenFont = NULL;
  215.  
  216. /* Texte für das Zahlungsform-MX-Gadget                        */
  217. UBYTE *Gadget300Labels[] = {
  218.     NULL,
  219.     NULL,
  220.     NULL,
  221.     NULL };
  222.  
  223. /* Zusätzliche Texte und deren Position                        */
  224. struct IntuiText BestellenIText[] = {
  225.     1, 0, JAM1,45, 014, NULL, NULL, NULL,
  226.     1, 0, JAM1,45, 132, NULL, NULL, NULL };
  227.  
  228. /* Anzahl zusätzlicher Texte                                        */
  229. #define Bestellen_TNUM 2
  230.  
  231. /* MenuStruktur füllen                                                */
  232. struct NewMenu BestellenNewMenu[] = {
  233.     NM_TITLE, NULL, NULL,    0, 0L, NULL,
  234.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  235.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_OPA),
  236.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_OPB),
  237.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  238.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SPA),
  239.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SPB),
  240.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  241.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SAA),
  242.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SAB),
  243.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_DRU),
  244.      NM_ITEM, (STRPTR)NM_BARLABEL, NULL,    0, 0L, NULL,
  245.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_INF),
  246.      NM_ITEM, (STRPTR)NM_BARLABEL, NULL,    0, 0L, NULL,
  247.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_HID),
  248.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_END),
  249.       NM_END, NULL, NULL,    0, 0L, NULL
  250. };
  251.  
  252. /* Gadgettypen definieren                                            */
  253. UWORD BestellenGTypes[] = {
  254.     LISTVIEW_KIND,
  255.     BUTTON_KIND,
  256.     BUTTON_KIND,
  257.     MX_KIND,
  258.     BUTTON_KIND,
  259.     BUTTON_KIND,
  260.     STRING_KIND,
  261.     STRING_KIND,
  262.     STRING_KIND,
  263.     STRING_KIND,
  264.     STRING_KIND,
  265.     STRING_KIND,
  266.     STRING_KIND,
  267.     STRING_KIND,
  268.     INTEGER_KIND
  269. };
  270.  
  271. /* Gadgets festlegen                                                    */
  272. struct NewGadget BestellenNGad[] = {
  273.     242,  24, 115, 156, NULL, NULL, GD_Diskliste, PLACETEXT_ABOVE, NULL, NULL,
  274.     242, 195,  47,  20, NULL, NULL, GD_NeueDisk, PLACETEXT_IN, NULL, NULL,
  275.     289, 195,  68,  20, NULL, NULL, GD_DiskLoeschen, PLACETEXT_IN, NULL, NULL,
  276.     361,  52,  17,   9, NULL, NULL, GD_Zahlart, PLACETEXT_RIGHT, NULL, NULL,
  277.       4, 225,  88,  20, NULL, NULL, GD_Drucken, PLACETEXT_IN, NULL, NULL,
  278.     366, 225,  88,  20, NULL, NULL, GD_Abbrechen, PLACETEXT_IN, NULL, NULL,
  279.      71,  28, 161,  20, NULL, NULL, GD_AName, PLACETEXT_LEFT, NULL, NULL,
  280.      71,  50, 161,  20, NULL, NULL, GD_AStrasse, PLACETEXT_LEFT, NULL, NULL,
  281.      71,  72, 161,  20, NULL, NULL, GD_AOrt, PLACETEXT_LEFT, NULL, NULL,
  282.      71,  94, 161,  20, NULL, NULL, GD_KundNr, PLACETEXT_LEFT, NULL, NULL,
  283.      71, 147, 161,  20, NULL, NULL, GD_EName, PLACETEXT_LEFT, NULL, NULL,
  284.      71, 169, 161,  20, NULL, NULL, GD_EStrasse, PLACETEXT_LEFT, NULL, NULL,
  285.      71, 191, 161,  20, NULL, NULL, GD_EOrt, PLACETEXT_LEFT, NULL, NULL,
  286.     242, 174, 115,  20, NULL, NULL, GD_DiskAender, 0, NULL, NULL,
  287.     361,  24,  86,  20, NULL, NULL, GD_Abstand, PLACETEXT_ABOVE, NULL, NULL
  288. };
  289.  
  290. /* Tags zu den Gadgets                                                */
  291. ULONG BestellenGTags[] = {
  292.     (GTLV_ShowSelected), 0, (GT_Underscore), '_', (TAG_DONE),
  293.     (GT_Underscore), '_', (TAG_DONE),
  294.     (GT_Underscore), '_', (TAG_DONE),
  295.     (GTMX_Labels), (ULONG)&Gadget300Labels[ 0 ], (GT_Underscore), '_', (TAG_DONE),
  296.     (GT_Underscore), '_', (TAG_DONE),
  297.     (GT_Underscore), '_', (TAG_DONE),
  298.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  299.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  300.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  301.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  302.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  303.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  304.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  305.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 14, (TAG_DONE),
  306.     (STRINGA_ExitHelp), TRUE, (GTIN_Number), 0, (GTIN_MaxChars), 3, (GT_Underscore), '_', (TAG_DONE)
  307. };
  308.  
  309. /* Vordefinieren sämtlicher im Programm vorkommender        */
  310. /* Unterprogramme                                                        */
  311.  
  312. /* Positionen nach Fontbreite umrechnen                        */
  313. static UWORD ComputeX( UWORD value );
  314.  
  315. /* Positionen nach Fonthöhe umrechnen                            */
  316. static UWORD ComputeY( UWORD value );
  317.  
  318. /* Computerbreite und -höhe Bestimmen                            */
  319. static void ComputeFont( UWORD width, UWORD height );
  320.  
  321. /* Voreinstellungen fürs Fenster (Screen vorbereiten)        */
  322. int SetupScreen( void );
  323.  
  324. /* Sreen wieder zurücksetzen                                        */
  325. void CloseDownScreen( void );
  326.  
  327. /* Texte und BevelBoxes aufs Fenster zeichnen                */
  328. void BestellenRender( void );
  329.  
  330. /* Fenster öffenen                                                    */
  331. int OpenBestellenWindow( void );
  332.  
  333. /* Fenster wieder dicht machen                                    */
  334. void CloseBestellenWindow( void );
  335.  
  336. /*    Gadtools-Gadget einschalten                                     */
  337. void gt_OnGadget( struct Gadget     *gad, struct Window        *w );
  338.  
  339. /*    ...und wieder aus...                                                */
  340. void gt_OffGadget( struct Gadget     *gad, struct Window    *w );
  341.  
  342. /*  String-Gadgets mit nem string füllen                        */
  343. void gt_SetString( struct Gadget    *gad,
  344.                    struct Window    *w,
  345.                    char                *string );
  346.  
  347. /* und nachschaun, welcher drinnen steckt                        */
  348. char * gt_GetString( struct Gadget    *gad );
  349.  
  350. /* Integer-Gadgets mit ner Zahl füllen                            */
  351. void gt_SetInteger( struct Gadget    *gad,
  352.                     struct Window    *w,
  353.                     LONG            value );
  354.  
  355. /* und nachschaun, welche drinnen steckt                        */
  356. LONG gt_GetInteger( struct Gadget    *gad );
  357.  
  358. /* Liste anhängen                                                        */
  359. void gt_AttachList(    struct Gadget     *lv,
  360.                     struct Window     *w,
  361.                      struct List     *list );
  362.  
  363. /* Aktuellen Eintrag setzen                                        */
  364. void gt_SetLV( struct Gadget    *gad,
  365.                struct Window    *w,
  366.                ULONG            value);
  367.  
  368. /* x-ten Eintrag aus einer Exec-Liste holen */
  369. struct Node * gt_GetListEntry( struct List *l,
  370.                                int num );
  371.  
  372. /* Nummer einer Node aus einer Liste feststellen            */
  373. int gt_GetListEntryNum(    struct List *l,
  374.                         struct Node *n );
  375.  
  376. /* Anzahl Einträge einer Liste zählen                            */
  377. int gt_GetListNumEntries( struct List *l );
  378.  
  379. /* Gadgets ein oder Ausschalten                                    */
  380. void checkonoff( void );
  381.  
  382. /* Neuer Eintrag in die Liste    aufnehmen                        */
  383. void newvdb( void );
  384.  
  385. /* Libraries öffnen                                                    */
  386. BOOL OpenAll();
  387.  
  388. /* Libraries schließen                                                */
  389. void CloseAll();
  390.  
  391. /* Unterprogramm zum Einlesen der Einstellungen                */
  392. void EinstLesen();
  393.  
  394. /* Unterprogramm zum Schreiben der Einstellungen            */
  395. void EinstSchreiben();
  396.  
  397. /* Sortiert einen neuen Eintrag in die Liste ein.            */
  398. long NeuerEintrag(char *Eintrag);
  399.  
  400. /* Einen Eintrag aus der Liste entfernen                        */
  401. void EintragLoeschen();
  402.  
  403. /* Unterprogramm zum Einlesen der Time-Diskettendaten        */
  404. void DatenLesen();
  405.  
  406. /* Unterprogramm zum Schreiben der Time-Diskettendaten    */
  407. void DatenSchreiben( struct List *l);
  408.  
  409. /* Die Bestellung auf eine Postkarte Drucken                    */
  410. void Drucken( struct List *l );
  411.  
  412. /* Window mit den Voreingestellten Daten füllen                */
  413. void Winfuell();
  414.  
  415. /* Wenn jemand versucht ein Gadget zu erdrücken                */
  416. BOOL Abfrage_Gadgetup( struct Gadget *gad, long code);
  417.  
  418. /* Jemand hat das Menu benutzt                                    */
  419. BOOL Abfrage_Menuepick( UWORD code);
  420.  
  421. /* Eine handelsübliche Taste wurde gedrückt                    */
  422. BOOL Abfrage_Vanillakey( struct Gadget *gad, UWORD code);
  423.  
  424. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  425. void Abfrage_Rawkey( struct Gadget *gad, UWORD code, struct Gadget *gd);
  426.  
  427. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  428. void Abfrage_Menuhelp( UWORD code);
  429.  
  430. /* Localisierte Texte einlesen (wenn vorhanden)                */
  431. void LocaleLesen();
  432.  
  433.  
  434. /* Positionen nach Fontbreite umrechnen                        */
  435. static UWORD ComputeX( UWORD value )
  436. {
  437.     return(( UWORD )((( FontX * value ) + 3 ) / (UWORD)7 ));
  438. }
  439.  
  440. /* Positionen nach Fonthöhe umrechnen                            */
  441. static UWORD ComputeY( UWORD value )
  442. {
  443.     return(( UWORD )((( FontY * value ) + 6 ) / (UWORD)12 ));
  444. }
  445.  
  446. /* Computerbreite und -höhe Bestimmen                            */
  447. static void ComputeFont( UWORD width, UWORD height )
  448. {
  449.     /* Voreingestellten Font benutzen                            */
  450.     Font = &Attr;
  451.     /* Fontname bestimmen                                            */
  452.     Font->ta_Name = (STRPTR)Scr->RastPort.Font->tf_Message.mn_Node.ln_Name;
  453.     /* Fonthöhe bestimmen                                            */
  454.     Font->ta_YSize = FontY = Scr->RastPort.Font->tf_YSize;
  455.     /* Fontbreite bestimmen                                            */
  456.     FontX = Scr->RastPort.Font->tf_XSize;
  457.  
  458.     /* minimaler horizontaler Abstand                            */
  459.     OffX = Scr->WBorLeft;
  460.     /* minimaler vertikaler Abstand                                */
  461.     OffY = Scr->RastPort.TxHeight + Scr->WBorTop + 1;
  462.  
  463.     /* Überprüfen, ob das Fenster nicht zu groß wird        */ 
  464.     if ( width && height ) {
  465.         /* Wenn es horizontal zu groß wird, oder                */
  466.         if (( ComputeX( width ) + OffX + Scr->WBorRight ) > Scr->Width )
  467.             goto UseTopaz;
  468.         /* vertikal, dann benutze den Topas 8 Font            */
  469.         if (( ComputeY( height ) + OffY + Scr->WBorBottom ) > Scr->Height )
  470.             goto UseTopaz;
  471.     }
  472.     return;
  473.  
  474. /* Topas Font verwenden, weils Fenster sonst zu groß wird*/
  475. UseTopaz:
  476.     Font->ta_Name = (STRPTR)"topaz.font";
  477.     FontX = FontY = Font->ta_YSize = 8;
  478. }
  479.  
  480. /* Voreinstellungen fürs Fenster (Screen vorbereiten)        */
  481. int SetupScreen( void )
  482. {
  483.     /* Schaun, ob wir nen PubScreen verwenden können        */
  484.     if ( ! ( Scr = LockPubScreen( PubScreenName )))
  485.         return( 1L );
  486.  
  487.     /* Schrifthöhe und -breit bestimmen                            */
  488.     ComputeFont( 0, 0 );
  489.  
  490.     /* Visualinfo setzen (Zeiger, wo es sichtbar wird)        */
  491.     if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
  492.         return( 2L );
  493.  
  494.     /* wenn alles glatt gegangen ist, 0 zurückgeben            */
  495.     return( 0L );
  496. }
  497.  
  498. /* Sreen wieder zurücksetzen                                        */
  499. void CloseDownScreen( void )
  500. {
  501.     /* falls wir ein VisualInfo gekriegt haben, freigeben    */
  502.     if ( VisualInfo ) {
  503.         FreeVisualInfo( VisualInfo );
  504.         VisualInfo = NULL;
  505.     }
  506.  
  507.     /* PubScreen wieder zurücksetzen                                */
  508.     if ( Scr        ) {
  509.         UnlockPubScreen( NULL, Scr );
  510.         Scr = NULL;
  511.     }
  512. }
  513.  
  514. /* Texte und BevelBoxes aufs Fenster zeichnen                */
  515. void BestellenRender( void )
  516. {
  517.     struct IntuiText    it;
  518.     UWORD            cnt;
  519.  
  520.     /* Font berechnen                                                    */
  521.     ComputeFont( BestellenWidth, BestellenHeight );
  522.  
  523.     /* Absenderumrandende BevelBox zeichnen                    */
  524.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 10 ),
  525.                     OffY + ComputeY( 24 ),
  526.                     ComputeX( 227 ),
  527.                     ComputeY( 94 ),
  528.                     GT_VisualInfo, VisualInfo, GTBB_Recessed, TRUE, TAG_DONE );
  529.     /* Empfängerumrandende BevelBox zeichnen                    */
  530.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 10 ),
  531.                     OffY + ComputeY( 143 ),
  532.                     ComputeX( 227 ),
  533.                     ComputeY( 72 ),
  534.                     GT_VisualInfo, VisualInfo, GTBB_Recessed, TRUE, TAG_DONE );
  535.         /* Allumrandende BevelBox zeichnen                            */
  536.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 2 ),
  537.                     OffY + ComputeY( 3 ),
  538.                     ComputeX( 453 ),
  539.                     ComputeY( 218 ),
  540.                     GT_VisualInfo, VisualInfo, TAG_DONE );
  541.  
  542.     /* Texte ausgeben                                                    */
  543.     for ( cnt = 0; cnt < Bestellen_TNUM; cnt++ ) {
  544.         /* Text aufbereiten                                            */
  545.         CopyMem(( char * )&BestellenIText[ cnt ], ( char * )&it, (long)sizeof( struct IntuiText ));
  546.         /* Font festlegen                                                */
  547.         it.ITextFont = Font;
  548.         /* horizontale Position festlegen                        */
  549.         it.LeftEdge  = OffX + ComputeX( it.LeftEdge ) - ( IntuiTextLength( &it ) >> 1 );
  550.         /* vertikale Position festlegen                            */
  551.         it.TopEdge   = OffY + ComputeY( it.TopEdge ) - ( Font->ta_YSize >> 1 );
  552.         /* Text ausgeben                                                */
  553.         PrintIText( BestellenWnd->RPort, &it, 0, 0 );
  554.     }
  555. }
  556.  
  557. /* Fenster öffenen                                                    */
  558. int OpenBestellenWindow( void )
  559. {
  560.     /* NewGadget Struktur konkret anlegen                        */
  561.     struct NewGadget    ng;
  562.     /* Gadget Struktur konkret anlegen                            */
  563.     struct Gadget    *g;
  564.     /* Zwei laufvariable definieren                                */
  565.     UWORD        lc, tc;
  566.     /* Für die horizontale und vertikale Größe                */
  567.     UWORD        ww, wh;
  568.  
  569.     /* Fontröße berechnen                                            */
  570.     ComputeFont( BestellenWidth, BestellenHeight );
  571.  
  572.     /* absolute Fenstergröße horizontal berechnen            */
  573.     ww = ComputeX( BestellenWidth );
  574.     /* absolute Fenstergröße vertikal berechnen                */
  575.     wh = ComputeY( BestellenHeight );
  576.  
  577.     /* Font öffnen, wenns fehlschlägt, Fehler zurückgeben    */
  578.     if ( ! ( BestellenFont = OpenDiskFont( Font )))
  579.         return( 5L );
  580.  
  581.     /* Liste fürs erstellen der Gadgets erstellen            */
  582.     if ( ! ( g = CreateContext( &BestellenGList )))
  583.         return( 1L );
  584.  
  585.     /* wiederhole, bis alle Gadgets erstellt sind            */
  586.     for( lc = 0, tc = 0; lc < Bestellen_CNT; lc++ )
  587.     {
  588.         /* Speicherbereich in dem die Liste definiert ist    */
  589.         /* an die Liste ranhängen                                    */
  590.         CopyMem((char * )&BestellenNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  591.  
  592.         /* VisualInfo an die Gadgetstructur übergeben        */
  593.         ng.ng_VisualInfo = VisualInfo;
  594.         /* Font fürs Gadget festlegen                                */
  595.         ng.ng_TextAttr   = Font;
  596.         /* horizontale Position errechnen                        */
  597.         ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  598.         /* vertikale Position errechnen                            */
  599.         ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  600.         /* Breite berechnen                                            */
  601.         ng.ng_Width      = ComputeX( ng.ng_Width );
  602.         /* und die Höhe berechnen                                    */
  603.         ng.ng_Height     = ComputeY( ng.ng_Height);
  604.  
  605.         /* Das ganze können wir jetzt mal herstellen            */
  606.         BestellenGadgets[ lc ] = g = CreateGadgetA((ULONG)BestellenGTypes[ lc ], g, &ng, ( struct TagItem * )&BestellenGTags[ tc ] );
  607.  
  608.         /* tc erhöhen                                                    */
  609.         while( BestellenGTags[ tc ] ) tc += 2;
  610.         tc++;
  611.  
  612.         /* Bei einem Fehler, brechen wir die Sache ab        */
  613.         if ( NOT g )
  614.             return( 2L );
  615.     }
  616.  
  617.     /* Menus noch vorbereiten                                        */
  618.     /* Unter OS 3.x                                                     */
  619.     if( NOS )
  620.     {
  621.         /* Verwenden wir die Prefs-Menü-Farben                    */
  622.         dri = GetScreenDrawInfo( Scr );
  623.         if ( ! ( BestellenMenus = CreateMenus( BestellenNewMenu, GTMN_FrontPen, dri->dri_Pens[BARDETAILPEN], GTMN_NewLookMenus, TRUE, TAG_DONE )))
  624.             return( 3L );
  625.     }
  626.     /* unter OS 2.x                                                    */
  627.     else
  628.     {
  629.         /* können wir standardmäßig die Farbe 0 verwenden    */
  630.         if ( ! ( BestellenMenus = CreateMenus( BestellenNewMenu, GTMN_FrontPen, 0L, TAG_DONE )))
  631.             return( 3L );
  632.     }
  633.  
  634.     /* und herstellen                                                    */
  635.     LayoutMenus( BestellenMenus, VisualInfo, TAG_DONE );
  636.  
  637.     /* Abstand von Oben ermitteln                                    */
  638.     if (WinX > 0)
  639.     {
  640.         if ((WinX + ww + OffX + Scr->WBorRight) > Scr->Width)
  641.         {
  642.             WinX = (Scr->Width - (ww + OffX + Scr->WBorRight));
  643.         }
  644.     }
  645.     else
  646.     {
  647.         WinX = (Scr->Width  - (ww + OffX + Scr->WBorRight )) / (UWORD)2;
  648.     }
  649.  
  650.     /* Abstand von Oben ermitteln                                    */
  651.     if (WinY > 0)
  652.     {
  653.         if ((WinY + wh + OffY + Scr->WBorBottom) > Scr->Height)
  654.         {
  655.             WinY = (Scr->Height - (wh + OffY + Scr->WBorBottom));
  656.         }
  657.     }
  658.     else
  659.     {
  660.         WinY = (Scr->Height - (wh + OffY + Scr->WBorBottom)) / (UWORD)2;
  661.     }
  662.  
  663.     /* Schon können wir es wagen, das Fenster zu öffnen    */
  664.     if ( ! ( BestellenWnd = OpenWindowTags( NULL,
  665.                 WA_Left,                WinX,
  666.                 WA_Top,                WinY,
  667.                 WA_Width,            ww + OffX + Scr->WBorRight,
  668.                 WA_Height,            wh + OffY + Scr->WBorBottom,
  669.                 WA_IDCMP,            IDCMP_CLOSEWINDOW|IDCMP_GADGETUP|IDCMP_GADGETDOWN|IDCMP_MENUHELP|IDCMP_MENUPICK|IDCMP_VANILLAKEY|IDCMP_GADGETHELP|IDCMP_RAWKEY,
  670.                 WA_Flags,            WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_NEWLOOKMENUS,
  671.                 WA_Gadgets,            BestellenGList,
  672.                 WA_Title,            WinTitel,
  673.                 WA_ScreenTitle,    (UBYTE *)AppStrings[MSG_ScreenName],
  674.                 WA_PubScreen,        Scr,
  675.                 WA_MenuHelp,        TRUE,
  676.                 WA_NewLookMenus,    TRUE,
  677.                 TAG_DONE )))
  678.     return( 4L );
  679.  
  680.     /* Signalbit des Fensters für abfrage merken                */
  681.     wndsigflag = 1L << BestellenWnd->UserPort->mp_SigBit;
  682.     /* Hängen wir das Menu noch dran                                */
  683.     SetMenuStrip( BestellenWnd, BestellenMenus );
  684.     /* Kurzer refresh, sonst schmiert uns das Ding ab        */
  685.     GT_RefreshWindow( BestellenWnd, NULL );
  686.  
  687.     /* Die Bevel Boxen und ein wenig Text draufzeichnen    */
  688.     BestellenRender();
  689.  
  690.     /* Fenster ist offen!                                            */
  691.     CX_Popup = TRUE;
  692.  
  693.     /* Gadgets sperren oder öffnen, wenn nötigt                */
  694.     checkonoff();
  695.  
  696.     /* HelpControl unter 3.x starten, wegen der Hilfe        */
  697.     if( NOS )
  698.     {
  699.         HelpControl(BestellenWnd, HC_GADGETHELP);
  700.     }
  701.  
  702.     /* Alles Klar Boss                                                */
  703.     return( 0L );
  704. }
  705.  
  706. /* Fenster wieder dicht machen                                    */
  707. void CloseBestellenWindow( void )
  708. {
  709.     /* Hat das mit den Menus hingehaun?                            */
  710.     if ( BestellenMenus      )
  711.     {
  712.         /* Vom Fenster abmontieren                                    */
  713.         ClearMenuStrip( BestellenWnd );
  714.         /* und freigeben                                                */
  715.         FreeMenus( BestellenMenus );
  716.         /* Vermerken, daß alles gelöscht wurde                    */
  717.         BestellenMenus = NULL;
  718.     }
  719.  
  720.     /* Konnte das Fenster geöffnet werden                        */
  721.     if ( BestellenWnd        )
  722.     {
  723.         /* Position des Fensters festhalten                        */
  724.         if( !(WinX = BestellenWnd->LeftEdge))
  725.             WinX = 1;
  726.         if( !(WinY = BestellenWnd->TopEdge))
  727.             WinY = 1;
  728.         if ( currentvdb );
  729.             ListPos = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  730.         /* dann machen wir es wieder zu (wird kalt drausen)*/
  731.         CloseWindow( BestellenWnd );
  732.         /* und vermerken das mal eben                                */
  733.         BestellenWnd = NULL;
  734.         CX_Popup = FALSE;
  735.     }
  736.  
  737.     /* Konnten die Gadgets erzeugt werden                        */
  738.     if ( BestellenGList      )
  739.     {
  740.         /* Befreien wir sie wieder                                    */
  741.         FreeGadgets( BestellenGList );
  742.         /* und vermerken auch dieses                                */
  743.         BestellenGList = NULL;
  744.     }
  745.  
  746.     /* Na, können Sie es sich denken? Konnte der Font...    */
  747.     if ( BestellenFont )
  748.     {
  749.         /* Dann schließen wir auch diesen                        */
  750.         CloseFont( BestellenFont );
  751.         /* und schreibens uns hinter die Löffel                */
  752.         BestellenFont = NULL;
  753.     }
  754. }
  755.  
  756. /*    Gadtools-Gadget einschalten                                     */
  757. void gt_OnGadget( struct Gadget     *gad,
  758.                   struct Window        *w )
  759. {
  760.     GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, FALSE, TAG_DONE );
  761. }
  762.  
  763. /*    ...und wieder aus...                                                */
  764. void gt_OffGadget( struct Gadget     *gad,
  765.                    struct Window    *w )
  766. {
  767.     GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, TRUE, TAG_DONE );
  768. }
  769.  
  770. /*  String-Gadgets mit nem string füllen                        */
  771. void gt_SetString( struct Gadget    *gad,
  772.                    struct Window    *w,
  773.                    char                *string )
  774. {
  775.     GT_SetGadgetAttrs( gad, w, NULL, GTST_String, string, TAG_DONE );
  776. }
  777.  
  778. /* und nachschaun, welcher drinnen steckt                        */
  779. char * gt_GetString( struct Gadget    *gad )
  780. {
  781.     struct StringInfo *si = gad->SpecialInfo;
  782.  
  783.     if( si )
  784.         return( ( char * ) si->Buffer );
  785.     else
  786.         return( NULL );
  787. }
  788.  
  789. /* Integer-Gadgets mit ner Zahl füllen                            */
  790. void gt_SetInteger( struct Gadget    *gad,
  791.                     struct Window    *w,
  792.                     LONG            value )
  793. {
  794.     GT_SetGadgetAttrs( gad, w, NULL, GTIN_Number, value, TAG_DONE );
  795. }
  796.  
  797. /* und nachschaun, welche drinnen steckt                        */
  798. LONG gt_GetInteger( struct Gadget    *gad )
  799. {
  800.     struct StringInfo *si = gad->SpecialInfo;
  801.  
  802.     if( si )
  803.         return( si->LongInt );
  804.     else
  805.         return( NULL );
  806.  
  807. }
  808.  
  809. /* Listenverwaltung für Listview-Gadgets                        */
  810.  
  811. /* Liste anhängen
  812.  * "list" kann ~0 (-1) sein, dann ist kein Listenzugriff möglich
  813.  */
  814.  
  815. void gt_AttachList(    struct Gadget     *lv,
  816.                     struct Window     *w,
  817.                      struct List     *list )
  818. {
  819.     GT_SetGadgetAttrs( lv, w, NULL, GTLV_Labels, list, TAG_DONE );
  820. }
  821.  
  822. /* Aktuellen Eintrag setzen
  823.  * incl. Automatischem Positionieren, wenn der Eintrag außerhalb
  824.  * des sichtbaren Bereichs ist (maximal 12 Einträge darstellbar)
  825.  */
  826. void gt_SetLV( struct Gadget    *gad,
  827.                struct Window    *w,
  828.                ULONG            value)
  829. {
  830.     ULONG i;
  831.     /* sollte ein Eintrag ausgewählt sein,                        */
  832.     if( value >= 0 )
  833.     {
  834.         /* schau nach, welcher ganz oben in der Liste steht*/
  835.         if( NOS )
  836.             GT_GetGadgetAttrs( gad, w, NULL, GTLV_Top, &i, TAG_DONE );
  837.         else
  838.             i = (LONG)(*(short *)(((char *)gad)+sizeof(struct Gadget)+4));
  839.         /* ist er größer als der gewählte,                        */
  840.         if(value < i)
  841.         {
  842.             /* dann rutschen wir ein wenig hoch in der Liste*/
  843.             i = value;
  844.             GT_SetGadgetAttrs( gad, w, NULL, GTLV_Top, i, TAG_DONE );
  845.         }
  846.         /* sollte er zu hoch sein,                                    */
  847.         else if((value - i) > (LVSicht - 2))
  848.         {
  849.             /* müssen wir die Liste ein wenig runterblätten    */
  850.             i = value - (LVSicht - 1);
  851.             GT_SetGadgetAttrs( gad, w, NULL, GTLV_Top, i, TAG_DONE );
  852.         }
  853.     }
  854.     /* Nun können der Eintrag ausgewählt werden.                */
  855.     GT_SetGadgetAttrs( gad, w, NULL, GTLV_Selected, value, TAG_DONE );
  856. }
  857.  
  858. /* x-ten Eintrag aus einer Exec-Liste holen */
  859. struct Node * gt_GetListEntry( struct List *l,
  860.                                int num )
  861. {
  862.     int count = 0;
  863.     struct Node *n = l->lh_Head;
  864.  
  865.     while( n->ln_Succ )
  866.     {
  867.         if( num==count ) return( n );
  868.         n = n->ln_Succ;
  869.         count++;
  870.     }
  871.     return( NULL );
  872. }
  873.  
  874. /* Nummer einer Node aus einer Liste feststellen
  875.  * -1 falls nicht in Liste
  876.  */
  877. int gt_GetListEntryNum(    struct List *l,
  878.                         struct Node *n )
  879. {
  880.     int count = 0;
  881.     struct Node *r = l->lh_Head;
  882.  
  883.     while( r->ln_Succ )
  884.     {
  885.         if( r==n ) return( count );
  886.         r = r->ln_Succ;
  887.         count++;
  888.     }
  889.     return( -1 );
  890. }
  891.  
  892. /* Anzahl Einträge einer Liste zählen                            */
  893. int gt_GetListNumEntries( struct List *l )
  894. {
  895.     int count = 0;
  896.     struct Node *n = l->lh_Head;
  897.  
  898.     while( n->ln_Succ )
  899.     {
  900.         n = n->ln_Succ;
  901.         count++;
  902.     }
  903.  
  904.     return( count );
  905. }
  906.  
  907. /* Gadgets ein oder Ausschalten                                    */
  908. void checkonoff( void )
  909. {
  910.     /* Wenn ein Eintrag aus der Liste angewählt ist,        */
  911.     if( currentvdb ) 
  912.     {
  913.         /* schalte die Gadgets ein                                    */
  914.         gt_OnGadget( BestellenGadgets[ GD_DiskLoeschen ], BestellenWnd );
  915.         gt_OnGadget( BestellenGadgets[ GD_DiskAender ], BestellenWnd );
  916.     }
  917.     else
  918.     {
  919.         /* ansonsten brauchen wir sie gerade mal nicht        */
  920.         gt_OffGadget( BestellenGadgets[ GD_DiskLoeschen ], BestellenWnd );
  921.         gt_OffGadget( BestellenGadgets[ GD_DiskAender ], BestellenWnd );
  922.     }
  923. }
  924.  
  925. /* Neuer Eintrag in die Liste    aufnehmen                        */
  926. void newvdb( void )
  927. {
  928.     /* Neue Sturktur anlegen                                        */
  929.     struct VDBnode *new;
  930.  
  931.     /* Speicher dafür reservieren                                    */
  932.     new = AllocVec( sizeof( *new ), MEMF_CLEAR );
  933.  
  934.     /* Nur weitermachen, wenn es geklappt hat                    */
  935.     if( !new )
  936.         return;
  937.  
  938.     /* den neuen Satz zum aktuellen machen                        */
  939.     currentvdb = new;
  940.     new->n.ln_Name = new->d.Name;
  941.  
  942.     /* der neue Satz lautet vorrübergehend "- ??? -"        */
  943.     strcpy( new->d.Name, "- ??? -" );
  944.  
  945.     /* Liste abhängen                                                    */
  946.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, (struct List *) ~0 );
  947.  
  948.     /* Priorität = ASCII-Wert des ersten Buchstaben            */
  949.     new->n.ln_Pri     = - new->d.Name[0];
  950.  
  951.     /* an die Liste nach Prioritäten sortiert anhängen        */    
  952.     Enqueue( &vdblist, (struct Node *) new );
  953.  
  954.     /* geänderte Liste wieder anhängen                            */
  955.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  956.  
  957.     /* im ListviewGadget aktivieren                                */
  958.     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) new));
  959.  
  960.     /* Wenn die Gadgets abgeschaltet sind, einschalten        */
  961.     checkonoff();
  962.  
  963.     /* den "- ??? -" ins String Gadget schreiben und zur    */
  964.     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  965.  
  966.     /* Änderung aktivieren, oder wollen Sie eine Test Disk*/
  967.     ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  968. }
  969.  
  970. /* Libraries öffnen                                                    */
  971. BOOL OpenAll()
  972. {
  973.     /* Kick 2.0 muß vorhanden sein                                */
  974.     /* Library-Versionen mind. 37                                    */
  975.  
  976.     /* Intuition.library in der 37er Version öffnen (3.x)    */
  977.     IntuitionBase = (struct IntuitionBase *)
  978.         OpenLibrary("intuition.library",37L);
  979.  
  980.     /* Graphics.library öffnen                                        */
  981.     GfxBase = (struct GfxBase *)
  982.         OpenLibrary("graphics.library",37L);
  983.  
  984.     /* GadTools.library öffnen                                        */
  985.    GadToolsBase = (struct Library *)
  986.         OpenLibrary("gadtools.library",37L);
  987.  
  988.     /* Wenn das geklappt hat                                        */
  989.     if( GadToolsBase )
  990.     {
  991.         /* OS 3.0 (V39) oder höher vorhanden?                    */
  992.         if( (GadToolsBase->lib_Version) > 38U )
  993.         {
  994.             NOS = TRUE;
  995.             LVSicht = 12;
  996.         }
  997.         else
  998.         {
  999.             NOS = FALSE;
  1000.             LVSicht = 11;
  1001.         }
  1002.     }
  1003.  
  1004.     /* Asl.library öffnen (nicht zwindend notwendig)        */
  1005.     AslBase       =
  1006.         OpenLibrary("asl.library", 37L);
  1007.  
  1008.     /* AmigaGuide.library (nicht zwingend notwendig)        */
  1009.     AmigaGuideBase =
  1010.         OpenLibrary("amigaguide.library", 0L);
  1011.  
  1012.     /* Locale.library (nicht zwingend notwendig)                */
  1013.     LocaleBase = (struct LocaleBase *)
  1014.         OpenLibrary("locale.library", 38L);
  1015.  
  1016.     /* Icon.library (nicht zwingend notwendig)                */
  1017.     IconBase = (struct IconBase *)
  1018.         OpenLibrary("icon.library", 37L);
  1019.  
  1020.     /* Commodities.library öffnen                                    */
  1021.     CxBase = (struct CxBase *)
  1022.         OpenLibrary("commodities.library", 37L);
  1023.  
  1024.     /* Hat es nicht geklappt, Fehler zurückgeben                */
  1025.     if(! CxBase            ||
  1026.         ! GadToolsBase    ||
  1027.         ! GfxBase        ||
  1028.         ! IntuitionBase)
  1029.         return FALSE;
  1030.     return TRUE;
  1031. }
  1032.  
  1033. /* Libraries schließen                                                */
  1034. void CloseAll()
  1035. {
  1036.     /* locale.library schließen, wenn sie offen ist            */
  1037.     if( CxBase )
  1038.         CloseLibrary( ( struct Library *)CxBase );
  1039.     /* Icon.library schließen, wenn sie offen ist            */
  1040.     if( IconBase )
  1041.         CloseLibrary( ( struct Library *)IconBase );
  1042.     /* locale.library schließen, wenn sie offen ist            */
  1043.     if( LocaleBase )
  1044.         CloseLibrary( ( struct Library *)LocaleBase );
  1045.     /* AmigaGuide.library schließen, wenn sie offen ist    */
  1046.     if( AmigaGuideBase )
  1047.         CloseLibrary( ( struct Library *)AmigaGuideBase );
  1048.     /* Asl.library schließen, wenn sie offen ist                */
  1049.     if( AslBase )
  1050.         CloseLibrary( ( struct Library *)AslBase );
  1051.     /* GadTools.library schließen, wenn sie offen ist        */
  1052.     if( GadToolsBase )
  1053.         CloseLibrary( ( struct Library *)GadToolsBase );
  1054.     /* Graphics.library schließen, wenn sie offen ist        */
  1055.     if( GfxBase )
  1056.         CloseLibrary( ( struct Library *)GfxBase );
  1057.     /* Intuition.library schließen, wenn sie offen ist        */
  1058.     if( IntuitionBase )
  1059.         CloseLibrary( ( struct Library *)IntuitionBase );
  1060.     return;
  1061. }
  1062.  
  1063. /* Unterprogramm zum Einlesen der Einstellungen                */
  1064. void EinstLesen()
  1065. {
  1066.     /* Datei öffnen                                                    */
  1067.     BPTR is;
  1068.     is = Open(Einst_File,MODE_OLDFILE);
  1069.     /* Wenn das geklappt hat,                                        */
  1070.     if(is)
  1071.     {
  1072.         /* lies die Einstellungen                                    */
  1073.         Read(is, &P1, sizeof( P1 ));
  1074.         /* Schließ die Datei wieder                                */
  1075.         Close(is);
  1076.     }
  1077. }
  1078.  
  1079. /* Unterprogramm zum Schreiben der Einstellungen            */
  1080. void EinstSchreiben()
  1081. {
  1082.     /* Datei öffnen                                                    */
  1083.     BPTR os;
  1084.     os = Open(Einst_File, MODE_NEWFILE);
  1085.     /* Wenn das geklappt hat,                                        */
  1086.     if(os)
  1087.     {
  1088.         /* schreib die Einstellungen                                */
  1089.         Write(os, &P1, sizeof( P1 ));
  1090.         /* Schließ die Datei wieder                                */
  1091.         Close(os);
  1092.     }
  1093. }
  1094.  
  1095. /* Sortiert einen neuen Eintrag in die Liste ein.            */
  1096. long NeuerEintrag(char *Eintrag)
  1097. {
  1098.     long Entries;
  1099.     long i;
  1100.     struct VDBnode *n;
  1101.     struct VDBnode *m;
  1102.  
  1103.     /* Anzahl der bereits existierenden Eintragungen        */
  1104.     Entries = gt_GetListNumEntries( &vdblist );
  1105.  
  1106.     /* Schleife vom Ende bis zum Anfang der Liste            */
  1107.     for( i = Entries-1; i >= 0; i--) 
  1108.     {
  1109.         /* Eintrag aus der Liste Holen                            */
  1110.         m = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1111.  
  1112.         /* Der Eintrag ist bereits vorhanden -> ignorieren    */
  1113.         if(strcmp(m->d.Name, Eintrag)==0)
  1114.             return i;
  1115.  
  1116.         /* Die richtige Stelle wurde gefunden -> Einfügen    */
  1117.         if(strcmp(m->d.Name, Eintrag)<0)
  1118.         {
  1119.             /* Speicher alokieren                                    */
  1120.             n = AllocVec( sizeof( *n ), MEMF_CLEAR );
  1121.             if( n )
  1122.             {
  1123.                 /* die ganze Sache aufbereiten                    */
  1124.                 strcpy(n->d.Name, Eintrag);
  1125.                 n->n.ln_Name = n->d.Name;
  1126.                 n->n.ln_Pri  = - n->d.Name[0];
  1127.                 /* und dahinter anhängen                            */
  1128.                 Insert( &vdblist, (struct Node *) n, (struct Node *) m );
  1129.             }
  1130.             /* Eingefügte Pos. = i+1, das geben wir zurück    */
  1131.             return ++i;
  1132.         }
  1133.     }
  1134.  
  1135.     /* Kein kleinerer Eintrag gefunden?                            */
  1136.     n = AllocVec( sizeof( *n ), MEMF_CLEAR );
  1137.     if( n )
  1138.     {
  1139.         /* die ganze Sache aufbereiten                            */
  1140.         strcpy(n->d.Name, Eintrag);
  1141.         n->n.ln_Name = n->d.Name;
  1142.         n->n.ln_Pri  = - n->d.Name[0];
  1143.         /* dann setz ihn vorne dran                                */
  1144.         AddHead( &vdblist, (struct Node *) n );
  1145.     }
  1146.     /* Eingefügte Position = 0, das geben wir zurück        */
  1147.     return 0;
  1148. }
  1149.  
  1150. /* Einen Eintrag aus der Liste entfernen                        */
  1151. void EintragLoeschen()
  1152. {
  1153.     long i;
  1154.     /* Wenn ein Eintrag ausgewählt ist                            */
  1155.     if(currentvdb)
  1156.     {
  1157.         /* Die Nummer des Eintrags bestimmen                    */
  1158.         i = gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb);
  1159.         /* Ist diese > 0, wird der nächste Eintrag eins kl.*/
  1160.         if(i > 0)
  1161.             i--;
  1162.         /* Ansonsten 0 (der Beginn der Liste)                    */
  1163.         else
  1164.             i = 0;
  1165.         /* Liste abhängen                                                */
  1166.         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, (struct List *) ~0 );
  1167.         /* Den Eintrag entfernen                                    */
  1168.         Remove( (struct Node *) currentvdb );
  1169.         /* ebenso den passenden Vektor                            */
  1170.         FreeVec( currentvdb );
  1171.         /* Liste wieder anhängen                                    */
  1172.         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, &vdblist );
  1173.         /* Neuer aktueller Eintrag (wenn Liste nicht leer)    */
  1174.         if (IsListEmpty( &vdblist ))
  1175.         {
  1176.             currentvdb = NULL;
  1177.             /* Feld darunter löschen                                */
  1178.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, "");
  1179.         }
  1180.         else
  1181.         {
  1182.             currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1183.             /* Neuen aktuellen Eintag in der Liste auswählen*/
  1184.             gt_SetLV( BestellenGadgets[ GD_Diskliste ], BestellenWnd, i );
  1185.             /* und im Feld darunter anzeigen                        */
  1186.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1187.         }
  1188.         /* Wenn keiner mehr drinnen ist, Gad. abschalten    */
  1189.         checkonoff();
  1190.     }
  1191. }
  1192.  
  1193. /* Unterprogramm zum Einlesen der Time-Diskettendaten        */
  1194. void DatenLesen()
  1195. {
  1196.     FILE *is;
  1197.     char lespuf[16];
  1198.  
  1199.     /* Liste initialisieren                                            */
  1200.     NewList( &vdblist );
  1201.     /* Bei Beginn noch keinen aktuellen Eintrag                */
  1202.     currentvdb = NULL;
  1203.  
  1204.     /* Datei öffnen zum lesen (read -> "r")                    */
  1205.     is = fopen(T_Remember, "r");
  1206.     if(is)
  1207.     {
  1208.         /* Solange was in der Datei steckt, lesen                */
  1209.         while(fgets(lespuf, 15, is))
  1210.         {
  1211.             /* und an die Liste dranhängen                        */
  1212.             NeuerEintrag(lespuf);
  1213.         }
  1214.         /* Hinterher die Datei wieder dicht machen            */
  1215.         fclose(is);
  1216.     }
  1217. }
  1218.  
  1219. /* Unterprogramm zum Schreiben der Time-Diskettendaten    */
  1220. void DatenSchreiben( struct List *l )
  1221. {
  1222.     int i = 0;
  1223.     struct Node *n = l->lh_Head;
  1224.     struct VDBnode *a;
  1225.     FILE *os;
  1226.  
  1227.     /* Datei zum Schreiben öffnen (write -> "w")                */
  1228.     os = fopen(T_Remember, "w");
  1229.     /* Hat das öffnen hingehauen                                    */
  1230.     if(os)
  1231.     {
  1232.         /* Die Liste von Anfang bis Schluß durchackern    */
  1233.         while( n->ln_Succ )
  1234.         {
  1235.             n = n->ln_Succ;
  1236.             a = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1237.             i++;
  1238.             /* Disknamen reinschreiben                            */
  1239.             fputs( a->d.Name, os );
  1240.             fputc( '\n', os);
  1241.         }
  1242.         /* Wenns öffnen geklappt hat, dann Datei schließ*/
  1243.         fclose(os);
  1244.     }
  1245. }
  1246.  
  1247. /* Die Bestellung auf eine Postkarte Drucken                    */
  1248. void Drucken( struct List *l )
  1249. {
  1250.     /* Einen Schreibpuffer für die aufbereiten der Zeilen    */
  1251.     char Schreibpuf[1000];
  1252.     char Zeilenpuf[60];
  1253.     char i;
  1254.     struct VDBnode *a;
  1255.     struct Node *n = l->lh_Head;
  1256.  
  1257.     FILE *os;
  1258.     /* Requester vorbereiten                                        */
  1259.     es.es_StructSize    = sizeof(struct EasyStruct);
  1260.     es.es_Flags            = 0;
  1261.  
  1262.     /* Datei zum drucken oder speichern öffnen                */
  1263.     os = fopen("PRT:", "w");
  1264.     /* Hats geklappt?                                                    */
  1265.     if(os)
  1266.     {
  1267.         /* Requester zur Aufford. die Postkarte einzul.        */
  1268.         es.es_Title            = AppStrings[MSG_DruReqTitel];
  1269.         es.es_TextFormat    = AppStrings[MSG_DruReqText1];
  1270.         es.es_GadgetFormat= AppStrings[MSG_DruReqWahl];
  1271.  
  1272.         /* Wenn er mit Drucken bestätigt wurde    i > 0            */
  1273.         i = EasyRequest(BestellenWnd, &es, NULL);
  1274.  
  1275.         /* Falls i > 0 drucken/speichern                            */
  1276.         if(i)
  1277.         {
  1278.             strcpy(Schreibpuf, '\0');
  1279.             /* Die Leerzeilen zu Beginn einfügen                */
  1280.             for( i = 0; i < P1.Abstand; i++)
  1281.             {
  1282.                 strcat(Schreibpuf, "\n")
  1283.             }
  1284.             /* Die Zeile mit dem Absendernamen drucken und    */
  1285.             strcat(Schreibpuf, "  ");
  1286.             strcat(Schreibpuf, P1.AName);
  1287.             strcat(Schreibpuf, "\n\n  ");
  1288.             /* Die Zeile mit der Kundennummer drucken und    */
  1289.             strcat(Schreibpuf, AppStrings[MSG_DruText0]);
  1290.             strcat(Schreibpuf, P1.KundNr);
  1291.             strcat(Schreibpuf, "\n\n  ");
  1292.             /* Die Zeile mit der Absenderstraße drucken und    */
  1293.             strcat(Schreibpuf, P1.AStrasse);
  1294.             strcat(Schreibpuf, "\n\n  ");
  1295.             /* Die Zeile mit dem Absenderort drucken und        */
  1296.             strcat(Schreibpuf, P1.AOrt);
  1297.             strcat(Schreibpuf, "\n\n                             ");
  1298.             /* Die Zeile mit dem Empfängernamen drucken und    */
  1299.             strcat(Schreibpuf, P1.EName);
  1300.             strcat(Schreibpuf, "\n\n\n\n                             ");
  1301.             /* Die Zeile mit der Empf.straße drucken und        */
  1302.             strcat(Schreibpuf, P1.EStrasse);
  1303.             strcat(Schreibpuf, "\n\n\n\n                             ");
  1304.             /* zuguterletzt den Empfängerort drucken und        */
  1305.             strcat(Schreibpuf, P1.EOrt);
  1306.             strcat(Schreibpuf, "\f");
  1307.             if (fputs( Schreibpuf, os ) == DOSTRUE)
  1308.             {
  1309.                 /* Schreiben klappte nicht                            */
  1310.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1311.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText1];
  1312.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1313.  
  1314.                 EasyRequest(BestellenWnd, &es, NULL);
  1315.                 os = NULL;
  1316.             }
  1317.         }
  1318.         /* und schließe die Datei wieder                            */
  1319.         fclose(os);
  1320.     }
  1321.  
  1322.     /* Datei zum drucken oder speichern öffnen                */
  1323.     os = fopen("PRT:", "w");
  1324.     /* Hats geklappt?                                                    */
  1325.     if(os)
  1326.     {
  1327.         /* Die Aufforderung, die Postkarte umzudrehen        */
  1328.         es.es_Title            = AppStrings[MSG_DruReqTitel];
  1329.         es.es_TextFormat    = AppStrings[MSG_DruReqText2];
  1330.         es.es_GadgetFormat= AppStrings[MSG_DruReqWahl];
  1331.  
  1332.         /* Wenn er mit Drucken bestätigt wurde                    */
  1333.         i = EasyRequest(BestellenWnd, &es, NULL);
  1334.  
  1335.         /* Wenn i > 0                                                    */
  1336.         if(i)
  1337.         {
  1338.             strcpy(Schreibpuf, '\0');
  1339.             /* Die Leerzeilen zu Beginn einfügen                */
  1340.             for( i = 0; i < P1.Abstand; i++)
  1341.             {
  1342.                 strcat(Schreibpuf, "\n")
  1343.             }
  1344.             /* Ein Text, der klar macht, was wir wollen        */
  1345.             strcat(Schreibpuf, AppStrings[MSG_DruText1]);
  1346.             /* Nachschaun, welche Zahlungsart aktuell ist    */
  1347.             switch( P1.Versart )
  1348.             {
  1349.                 /* Nachnahme,                                            */
  1350.                 case 0:
  1351.                     strcat(Schreibpuf, AppStrings[MSG_DruText2]);
  1352.                     break;
  1353.                 /* Vorkasse oder                                        */
  1354.                 case 1:
  1355.                     strcat(Schreibpuf, AppStrings[MSG_DruText3]);
  1356.                     break;
  1357.                 /* gegen Rechnung                                        */
  1358.                 default:
  1359.                     strcat(Schreibpuf, AppStrings[MSG_DruText4]);
  1360.                     break;
  1361.             }
  1362.             strcpy(Zeilenpuf, "  ");
  1363.             i = 0;
  1364.             /* Nun zu den Disketten selbst                        */
  1365.             while( n->ln_Succ )
  1366.             {
  1367.                 /* Zunächst holen wir mal die Diskbezeichn.,    */
  1368.                 n = n->ln_Succ;
  1369.                 a = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1370.                 i++;
  1371.                 /* schaun ob in der Zeile noch Platz ist,        */
  1372.                 if((strlen(a->d.Name) + strlen(Zeilenpuf)) > 52 )
  1373.                 {
  1374.                     /* wenn nicht, drucken wir die alte und    */
  1375.                     strcat( Schreibpuf, Zeilenpuf );
  1376.                     strcat( Schreibpuf, "\n");
  1377.                     /* beginnen eine neue                            */
  1378.                     strcpy(Zeilenpuf, "  ");
  1379.                 }
  1380.                 /* nun können wir getrost die Diskettenbez.    */
  1381.                 strcat(Zeilenpuf, a->d.Name);
  1382.                 /* gefolgt von einem Komma dranhängen            */
  1383.                 strcat(Zeilenpuf, ", ");
  1384.             }
  1385.             /* Da die letzte Zeile nicht gedruckt wurde,        */
  1386.             /* holen wir das nach und                                */
  1387.             strcat( Schreibpuf, Zeilenpuf );
  1388.             /* hängen eine Leerzeile dran.                        */
  1389.             strcat( Schreibpuf, "\n\n" );
  1390.             /* In der Hoffnung das es auch wirklich flott    */
  1391.             /* geht, danken wir dafür schon im Voraus,        */
  1392.             strcat(Schreibpuf, AppStrings[MSG_DruText5]);
  1393.             if (fputs( Schreibpuf, os ) == DOSTRUE)
  1394.             {
  1395.                 /* Schreiben klappte nicht                            */
  1396.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1397.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText1];
  1398.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1399.  
  1400.                 EasyRequest(BestellenWnd, &es, NULL);
  1401.             }
  1402.         }
  1403.         /* und schließen die Datei wieder                        */
  1404.         fclose(os);
  1405.     }
  1406.     /* Konnte die Datei jedoch nicht geöffnet werden,        */
  1407.     else
  1408.     {
  1409.         /* wird der Benuter per Requester Informiert            */
  1410.         es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1411.         es.es_TextFormat    = AppStrings[MSG_ErrorReqText2];
  1412.         es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1413.  
  1414.         EasyRequest(BestellenWnd, &es, NULL);
  1415.     }
  1416. }
  1417.  
  1418. /* Window mit den Voreingestellten Daten füllen                */
  1419. void Winfuell()
  1420. {
  1421.     /* Daten in das ListView Gadget einbauen                    */
  1422.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  1423.  
  1424.     /* Voreinstellungen einbauen                                    */
  1425.     GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1426.                                 GTMX_Active, P1.Versart,
  1427.                                 TAG_DONE);
  1428.     gt_SetString( BestellenGadgets[ GD_AName ], BestellenWnd, P1.AName );
  1429.     gt_SetString( BestellenGadgets[ GD_AStrasse ], BestellenWnd, P1.AStrasse);
  1430.     gt_SetString( BestellenGadgets[ GD_AOrt ], BestellenWnd, P1.AOrt);
  1431.     gt_SetString( BestellenGadgets[ GD_KundNr ], BestellenWnd, P1.KundNr );
  1432.  
  1433.     gt_SetString( BestellenGadgets[ GD_EName ], BestellenWnd, P1.EName );
  1434.     gt_SetString( BestellenGadgets[ GD_EStrasse ], BestellenWnd, P1.EStrasse);
  1435.     gt_SetString( BestellenGadgets[ GD_EOrt ], BestellenWnd, P1.EOrt);
  1436.  
  1437.     gt_SetInteger( BestellenGadgets[ GD_Abstand ], BestellenWnd, P1.Abstand);
  1438.     /* momentan nicht benötigte Gadgets sperren                */
  1439.     checkonoff();
  1440. }
  1441.  
  1442. /* Wenn jemand versucht ein Gadget zu erdrücken                */
  1443. BOOL Abfrage_Gadgetup( struct Gadget *gad, long code)
  1444. {
  1445.     char Merken[15];
  1446.     long i = 0;
  1447.     BOOL terminated = FALSE;    
  1448.  
  1449.     /* Wenn die Help-Taste der Grund fürs Beenden des G.    */
  1450.     if(code==95)
  1451.     {
  1452.         /* Rufen wir die Rawkey-Abfrage auf (HELP-Behandl.)*/
  1453.         Abfrage_Rawkey(gad,code,gad);
  1454.         /* mehr gibts nicht zu tun, also ab nach Hause        */
  1455.         return terminated;
  1456.     }
  1457.  
  1458.     /* mal sehen, auf welches G. der User es abgesehen hat*/
  1459.     switch( gad->GadgetID )
  1460.     {
  1461.         /* Jemand hat auf die Liste geklickt                    */
  1462.         case GD_Diskliste:
  1463.             /* dann gibts einen neuen aktuellen Eintrag        */
  1464.             currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, code );
  1465.             /* eventuell gesperrte Gadgets freigeben            */
  1466.             checkonoff();
  1467.             /* Stringgadget unter der Liste füllen                */
  1468.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1469.             /* und aktivieren                                            */
  1470.             ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  1471.             break;
  1472.  
  1473.         /* Jemand will ne neue Disk eingeben                    */
  1474.         case GD_NeueDisk:
  1475.             /* Dafür haben wir ein Unerprogramm                    */
  1476.             newvdb();
  1477.             break;
  1478.  
  1479.         /* Jemand will ne Disk löschen                            */
  1480.         case GD_DiskLoeschen:
  1481.             /* auch dafür gibts ein Unterprogramm                */
  1482.             EintragLoeschen();
  1483.             break;
  1484.         /* Zahlart wurde geändert                                    */
  1485.         case GD_Zahlart:
  1486.             /* einfach nur merken, das reicht schon            */
  1487.             P1.Versart = code;
  1488.             break;
  1489.         /* Drucken                                                        */
  1490.         case GD_Drucken:
  1491.             /* Druckroutine aufrufen                                */
  1492.             Drucken(&vdblist);
  1493.             break;
  1494.         /* Abbrechen                                                    */
  1495.         case GD_Abbrechen:
  1496.             /* zurückgeben, daß der User keine Lust mer hat    */
  1497.             terminated = TRUE;
  1498.             break;
  1499.         /* Absendername                                                */
  1500.         case GD_AName:
  1501.             /* Einfach nur den neuen Namen merken                */
  1502.             strcpy( P1.AName, gt_GetString( BestellenGadgets[ GD_AName ]) );
  1503.             break;
  1504.         /* Absenderstraße                                                */
  1505.         case GD_AStrasse:
  1506.             /* Einfach nur die neue Straße merken                */
  1507.             strcpy( P1.AStrasse, gt_GetString( BestellenGadgets[ GD_AStrasse ]) );
  1508.             break;
  1509.         /* Absenderort                                                    */
  1510.         case GD_AOrt:
  1511.             /* Einfach nur den Ort merken                            */
  1512.             strcpy( P1.AOrt, gt_GetString( BestellenGadgets[ GD_AOrt ]) );
  1513.             break;
  1514.         /* Kundennummer                                                */
  1515.         case GD_KundNr:
  1516.             /* Einfach nur die Kundennummer merken                */
  1517.             strcpy( P1.KundNr, gt_GetString( BestellenGadgets[ GD_KundNr ]) );
  1518.             break;
  1519.         /* Empfängername                                                */
  1520.         case GD_EName:
  1521.             /* Einfach nur den Namen merken                        */
  1522.             strcpy( P1.EName, gt_GetString( BestellenGadgets[ GD_EName ]) );
  1523.             break;
  1524.         /* Empfängerstrasse                                            */
  1525.         case GD_EStrasse:
  1526.             /* Einfach nur die Strasse merken                    */
  1527.             strcpy( P1.EStrasse, gt_GetString( BestellenGadgets[ GD_EStrasse ]) );
  1528.             break;
  1529.         /* Empfängerort                                                */
  1530.         case GD_EOrt:
  1531.             /* Einfach nur den Ort merken                            */
  1532.             strcpy( P1.EOrt, gt_GetString( BestellenGadgets[ GD_EOrt ]) );
  1533.             break;
  1534.         /* Diskette neu angelegt oder alte ändern                */
  1535.         case GD_DiskAender:
  1536.             /* Den neuen Namen Merken                                */
  1537.             strcpy(Merken, gt_GetString( BestellenGadgets[ GD_DiskAender ]) );
  1538.             /* Wenn er sich nicht geändert hat, ignorieren    */
  1539.             if(strcmp(currentvdb->d.Name, Merken)==0) {}
  1540.             /* aber sonst                                                */
  1541.             else
  1542.             {
  1543.                 /* löschen wir den alten Eintrag                    */
  1544.                 EintragLoeschen();
  1545.                 /* Hängen die Liste ab                                */
  1546.                 gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, (struct List *) ~0 );
  1547.                 /* den neuen Eintrag an (Position merken)        */
  1548.                 i = NeuerEintrag( Merken );
  1549.                 /* hängen die Liste wieder dran                    */
  1550.                 gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  1551.                 /* aktivieren den neuen Eintrag                    */
  1552.                 gt_SetLV( BestellenGadgets[GD_Diskliste], BestellenWnd, i );
  1553.                 /* merken ihn uns als aktuellen                    */
  1554.                 currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1555.                 /* schalten alle Gadgets an und                    */
  1556.                 checkonoff();
  1557.                 /* setzen den Namen ins Feld unter der Liste    */
  1558.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1559.             }
  1560.             break;
  1561.         /* Abstand fürs Drucken                                        */
  1562.         case GD_Abstand:
  1563.             /* Den Abstand einfach nur merken                    */
  1564.             P1.Abstand = gt_GetInteger( BestellenGadgets[ GD_Abstand ]);
  1565.             break;
  1566.         /* Dürfte nicht vorkommen, aber sicher ist sicher!    */
  1567.         default:
  1568.             break;
  1569.     }
  1570.     /* Und ab nach Hause, mit Rückgabewert, ob Schluß ist    */
  1571.     return(terminated);
  1572. }
  1573.  
  1574. /* Jemand hat das Menu benutzt                                    */
  1575. BOOL Abfrage_Menuepick( UWORD code)
  1576. {
  1577.     /* Struktur für den Requester, falls wir ihn brauchen    */
  1578.     char Verzeichnis[128];
  1579.     struct MenuItem *item;
  1580.     struct VDBnode *n;
  1581.     unsigned i;
  1582.     BOOL terminated = FALSE;
  1583.     item = ItemAddress(BestellenMenus, code);
  1584.  
  1585.     /* Nichts ausgewählt, dann zurück                            */
  1586.     if( !item )
  1587.         return terminated;
  1588.  
  1589.     /* mal schaun, was ausgewählt wurde                            */
  1590.     switch ( (int)MENU_USERDATA(item) )
  1591.     {
  1592.         /* Menupunkt Öffnen Adressen/Einstellungen            */
  1593.         case MENU_FOO_OPA:
  1594.             /* Wenn die Asl.library geöffnet werden konnte    */
  1595.             if( AslBase )
  1596.             {
  1597.                 /* Verzeichnis ermitteln                            */
  1598.                 i = (unsigned)((STRPTR)PathPart(Einst_File) - (STRPTR)Einst_File);
  1599.                 strncpy(Verzeichnis,Einst_File,i);
  1600.                 Verzeichnis[i] = 0;
  1601.                 /* Öffne einen einfachen Filerequester            */
  1602.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1603.                                                                                         ASL_Dir, Verzeichnis,
  1604.                                                                                         ASL_File, FilePart(Einst_File),
  1605.                                                                                         TAG_DONE))
  1606.                 {
  1607.                     if(AslRequest(fr,NULL))
  1608.                     {
  1609.                         /* Der neue Filerequester setzt sich    */
  1610.                         /* aus Drawer und File zusammen.            */
  1611.                         strcpy(Einst_File, fr->fr_Drawer);
  1612.                         strcat(Einst_File, fr->fr_File);
  1613.                         /* Gut, schreibe die Bestellung            */
  1614.                         EinstLesen();
  1615.                         /* Und auf den Bildschirm damit            */
  1616.                         Winfuell();
  1617.                     }
  1618.                     FreeAslRequest(fr);
  1619.                 }
  1620.             }
  1621.             break;
  1622.  
  1623.         /* Menupunkt Öffnen Diskettenliste                        */
  1624.         case MENU_FOO_OPB:
  1625.             /* Wenn die Asl.library geöffnet werden konnte    */
  1626.             if( AslBase )
  1627.             {
  1628.                 /* Verzeichnis ermitteln                            */
  1629.                 i = (unsigned)((STRPTR)PathPart(T_Remember) - (STRPTR)T_Remember);
  1630.                 strncpy(Verzeichnis,T_Remember,i);
  1631.                 Verzeichnis[i] = 0;
  1632.                 /* Öffne einen einfachen Filerequester            */
  1633.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1634.                                                                                         ASL_Dir, Verzeichnis,
  1635.                                                                                         ASL_File, FilePart(T_Remember),
  1636.                                                                                         TAG_DONE))
  1637.                 {
  1638.                     if(AslRequest(fr,NULL))
  1639.                     {
  1640.                         /* Der neue Filerequester setzt sich    */
  1641.                         /* aus Drawer und File zusammen.            */
  1642.                         strcpy(T_Remember, fr->fr_Drawer);
  1643.                         strcat(T_Remember, fr->fr_File);
  1644.                         /* Liste abhängen                                */
  1645.                         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, (struct List *) ~0 );
  1646.                         /* Alte Liste löschen                        */
  1647.                         while( ( n = (struct VDBnode *) RemHead( &vdblist ) ) )
  1648.                         {
  1649.                             FreeVec(n);
  1650.                         }
  1651.                         /* Gut, schreibe die Bestellung            */
  1652.                         DatenLesen();
  1653.                         /* Liste wieder dranhängen                    */
  1654.                         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, &vdblist );
  1655.                         /* Bearbeitungsgadget löschen                */
  1656.                         gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, "");
  1657.                         /* Gadgets ausblenden                        */
  1658.                         checkonoff();
  1659.                     }
  1660.                     FreeAslRequest(fr);
  1661.                 }
  1662.             }
  1663.             break;
  1664.  
  1665.         /* Menupunkt Speichern Adressen/Einstellungen        */
  1666.         case MENU_FOO_SPA:
  1667.             EinstSchreiben();
  1668.             break;
  1669.  
  1670.         /* Menupunkt Speichern Diskettenliste                    */
  1671.         case MENU_FOO_SPB:
  1672.             DatenSchreiben(&vdblist);
  1673.             break;
  1674.  
  1675.         /* Menupunkt Speichern als ... Adressen/Einstell.    */
  1676.         case MENU_FOO_SAA:
  1677.             /* Wenn die Asl.library geöffnet werden konnte    */
  1678.             if( AslBase )
  1679.             {
  1680.                 /* Verzeichnis ermitteln                            */
  1681.                 i = (unsigned)((STRPTR)PathPart(Einst_File) - (STRPTR)Einst_File);
  1682.                 strncpy(Verzeichnis,Einst_File,i);
  1683.                 Verzeichnis[i] = 0;
  1684.                 /* Öffne einen einfachen Filerequester            */
  1685.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1686.                                                                                         ASL_Dir, Verzeichnis,
  1687.                                                                                         ASL_File, FilePart(Einst_File),
  1688.                                                                                         TAG_DONE))
  1689.                 {
  1690.                     if(AslRequest(fr,NULL))
  1691.                     {
  1692.                         /* Der neue Filerequester setzt sich    */
  1693.                         /* aus Drawer und File zusammen.            */
  1694.                         strcpy(Einst_File, fr->fr_Drawer);
  1695.                         strcat(Einst_File, fr->fr_File);
  1696.                         EinstSchreiben();
  1697.                     }
  1698.                     FreeAslRequest(fr);
  1699.                 }
  1700.             }
  1701.             break;
  1702.  
  1703.         /* Menupunkt Speichern als ... Diskettenliste        */
  1704.         case MENU_FOO_SAB:
  1705.             /* Wenn die Asl.library geöffnet werden konnte    */
  1706.             if( AslBase )
  1707.             {
  1708.                 /* Verzeichnis ermitteln                            */
  1709.                 i = (unsigned)((STRPTR)PathPart(T_Remember) - (STRPTR)T_Remember);
  1710.                 strncpy(Verzeichnis,T_Remember,i);
  1711.                 Verzeichnis[i] = 0;
  1712.                 /* Öffne einen einfachen Filerequester            */
  1713.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1714.                                                                                         ASL_Dir, Verzeichnis,
  1715.                                                                                         ASL_File, FilePart(T_Remember),
  1716.                                                                                         TAG_DONE))
  1717.                 {
  1718.                     if(AslRequest(fr,NULL))
  1719.                     {
  1720.                         /* Der neue Filerequester setzt sich    */
  1721.                         /* aus Drawer und File zusammen.            */
  1722.                         strcpy(T_Remember, fr->fr_Drawer);
  1723.                         strcat(T_Remember, fr->fr_File);
  1724.                         DatenSchreiben( &vdblist );
  1725.                     }
  1726.                     FreeAslRequest(fr);
  1727.                 }
  1728.             }
  1729.             break;
  1730.  
  1731.         /* Menupunkt Drucken                                            */
  1732.         case MENU_FOO_DRU:
  1733.             /* Unterprogramm zum Drucken starten                */
  1734.             Drucken(&vdblist);
  1735.             break;
  1736.  
  1737.         /* Menupunkt Information                                    */
  1738.         case MENU_FOO_INF:
  1739.             /* Starten wir nen kleinen Inforequester            */
  1740.             es.es_StructSize    = sizeof(struct EasyStruct);
  1741.             es.es_Flags            = 0;
  1742.             es.es_Title            = AppStrings[MSG_InfoReqTitel];
  1743.             es.es_TextFormat    = AppStrings[MSG_InfoReqText];
  1744.             es.es_GadgetFormat= AppStrings[MSG_InfoReqWahl];
  1745.  
  1746.             EasyRequest(BestellenWnd, &es, NULL);
  1747.             break;
  1748.  
  1749.         /* Menupunkt Verbergen                                        */
  1750.         case MENU_FOO_HID:
  1751.             /* Fenster schließen                                        */
  1752.             CloseBestellenWindow();
  1753.             break;
  1754.  
  1755.         /* Menupunkt Programm beenden                                */
  1756.         case MENU_FOO_END:
  1757.             /* gut, Rückgabewert auf Ende setzen                */
  1758.             terminated = TRUE;
  1759.             break;
  1760.  
  1761.         /* Sollte nicht vorkommen                                    */
  1762.         default:
  1763.             break;
  1764.     }
  1765.     /* Rückgabewert, ob der User weitermachen will            */
  1766.     return(terminated);
  1767. }
  1768.  
  1769. /* Eine handelsübliche Taste wurde gedrückt                    */
  1770. BOOL Abfrage_Vanillakey( struct Gadget *gad, UWORD code)
  1771. {
  1772.     BOOL terminated = FALSE;
  1773.  
  1774.     /* Wollen wir doch mal sehen, welche da benutzt wurde    */
  1775.     if ((code == AppStrings[MSG_GadgetKey1a][0]) ||
  1776.         (code == AppStrings[MSG_GadgetKey1b][0]))
  1777.         {
  1778.             /* ist ein Eintrag in der liste ausgewählt?        */
  1779.             if( currentvdb )
  1780.                 /* ja, dann aktiviere das Feld unter der Liste*/
  1781.                 ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  1782.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  1783.             {
  1784.                 /* nein, dann selektiere den ersten Eintrag    */
  1785.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, 0);
  1786.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1787.                 /* aktiviere alle Gadgets                            */
  1788.                 checkonoff();
  1789.                 /* und setz den Disknamen ins String-Gadget    */
  1790.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1791.             }
  1792.         }
  1793.  
  1794.         /* Neuer Listeneintrag                                        */
  1795.     else if ((code == AppStrings[MSG_GadgetKey2a][0]) ||
  1796.         (code == AppStrings[MSG_GadgetKey2b][0]))
  1797.         {
  1798.             /* dafür haben wir doch ein Unterprogramm            */
  1799.             newvdb();
  1800.         }
  1801.  
  1802.         /* Jemand will nen Diskeintrag löschen                    */
  1803.     else if ((code == AppStrings[MSG_GadgetKey3a][0]) ||
  1804.         (code == AppStrings[MSG_GadgetKey3b][0]))
  1805.         {
  1806.             /* Nur wenn ein Eintrag aktiviert ist löschen    */
  1807.             if( currentvdb )
  1808.                 EintragLoeschen();
  1809.         }
  1810.  
  1811.         /* Drucken                                                        */
  1812.     else if ((code == AppStrings[MSG_GadgetKey5a][0]) ||
  1813.         (code == AppStrings[MSG_GadgetKey5b][0]))
  1814.         {
  1815.             /* Druckroutine starten                                    */
  1816.             Drucken(&vdblist);
  1817.         }
  1818.  
  1819.         /* Abbrechen                                                    */
  1820.     else if ((code == AppStrings[MSG_GadgetKey6a][0]) ||
  1821.         (code == AppStrings[MSG_GadgetKey6b][0]))
  1822.         {
  1823.             /* Wenn er nimmer will, halten wir ihn nicht auf*/
  1824.             terminated = TRUE;
  1825.         }
  1826.  
  1827.         /* Absendername                                                */
  1828.     else if ((code == AppStrings[MSG_GadgetKey7a][0]) ||
  1829.         (code == AppStrings[MSG_GadgetKey7b][0]))
  1830.         {
  1831.             ActivateGadget( BestellenGadgets[GD_AName], BestellenWnd, NULL );
  1832.         }
  1833.  
  1834.         /* Absenderstraße                                                */
  1835.     else if ((code == AppStrings[MSG_GadgetKey8a][0]) ||
  1836.         (code == AppStrings[MSG_GadgetKey8b][0]))
  1837.         {
  1838.             ActivateGadget( BestellenGadgets[GD_AStrasse], BestellenWnd, NULL );
  1839.         }
  1840.  
  1841.         /* Absenderort                                                    */
  1842.     else if ((code == AppStrings[MSG_GadgetKey9a][0]) ||
  1843.         (code == AppStrings[MSG_GadgetKey9b][0]))
  1844.         {
  1845.             ActivateGadget( BestellenGadgets[GD_AOrt], BestellenWnd, NULL );
  1846.         }
  1847.  
  1848.         /* Kundennummer                                                */
  1849.     else if ((code == AppStrings[MSG_GadgetKey10a][0]) ||
  1850.         (code == AppStrings[MSG_GadgetKey10b][0]))
  1851.         {
  1852.             ActivateGadget( BestellenGadgets[GD_KundNr], BestellenWnd, NULL );
  1853.         }
  1854.  
  1855.         /* Empfängername                                                */
  1856.     else if ((code == AppStrings[MSG_GadgetKey11a][0]) ||
  1857.         (code == AppStrings[MSG_GadgetKey11b][0]))
  1858.         {
  1859.             ActivateGadget( BestellenGadgets[GD_EName], BestellenWnd, NULL );
  1860.         }
  1861.  
  1862.         /* Empfängerstraße                                            */
  1863.     else if ((code == AppStrings[MSG_GadgetKey12a][0]) ||
  1864.         (code == AppStrings[MSG_GadgetKey12b][0]))
  1865.         {
  1866.             ActivateGadget( BestellenGadgets[GD_EStrasse], BestellenWnd, NULL );
  1867.         }
  1868.  
  1869.         /* Empfänger Postleitzahl/Ort                                */
  1870.     else if ((code == AppStrings[MSG_GadgetKey13a][0]) ||
  1871.         (code == AppStrings[MSG_GadgetKey13b][0]))
  1872.         {
  1873.             ActivateGadget( BestellenGadgets[GD_EOrt], BestellenWnd, NULL );
  1874.         }
  1875.  
  1876.         /* Leerzeilen vorm Ausdruck                                */
  1877.     else if ((code == AppStrings[MSG_GadgetKey15a][0]) ||
  1878.         (code == AppStrings[MSG_GadgetKey15b][0]))
  1879.         {
  1880.             ActivateGadget( BestellenGadgets[GD_Abstand], BestellenWnd, NULL );
  1881.         }
  1882.  
  1883.         /* Zahlungsart Nachnahme                                    */
  1884.     else if ((code == AppStrings[MSG_VerKey1a][0]) ||
  1885.         (code == AppStrings[MSG_VerKey1b][0]))
  1886.         {
  1887.             P1.Versart = 0;
  1888.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1889.                                         GTMX_Active, P1.Versart,
  1890.                                         TAG_DONE);
  1891.         }
  1892.  
  1893.         /* Zahlungsart Vorkasse                                        */
  1894.     else if ((code == AppStrings[MSG_VerKey2a][0]) ||
  1895.         (code == AppStrings[MSG_VerKey2b][0]))
  1896.         {
  1897.             P1.Versart = 1;
  1898.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1899.                                         GTMX_Active, P1.Versart,
  1900.                                         TAG_DONE);
  1901.         }
  1902.  
  1903.         /* Zahlungsart Rechnung                                        */
  1904.     else if ((code == AppStrings[MSG_VerKey3a][0]) ||
  1905.         (code == AppStrings[MSG_VerKey3b][0]))
  1906.         {
  1907.             P1.Versart = 2;
  1908.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1909.                                         GTMX_Active, P1.Versart,
  1910.                                         TAG_DONE);
  1911.         }
  1912.  
  1913.         /* andere Eingaben interressieren uns nicht            */
  1914.     else
  1915.         {
  1916.         }
  1917.     /* und der der obligatorische Rückgabewert                */
  1918.     return(terminated);
  1919. }
  1920.  
  1921. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  1922. void Abfrage_Rawkey( struct Gadget *gad, UWORD code, struct Gadget *gd)
  1923. {
  1924.     int i;
  1925.  
  1926.     /* Ein paar Sachen für einen AmigaGuide aufruf            */
  1927.     struct NewAmigaGuide sync = {NULL};
  1928.     static UBYTE *AG_ID[] = {
  1929.         "GD_Diskliste",
  1930.         "GD_NeueDisk",
  1931.         "GD_DiskLoeschen",
  1932.         "GD_Zahlart",
  1933.         "GD_Drucken",
  1934.         "GD_Abbrechen",
  1935.         "GD_AName",
  1936.         "GD_AStrasse",
  1937.         "GD_AOrt",
  1938.         "GD_KundNr",
  1939.         "GD_EName",
  1940.         "GD_EStrasse",
  1941.         "GD_EOrt",
  1942.         "GD_DiskAender",
  1943.         "GD_Abstand",
  1944.     };
  1945.  
  1946.     AMIGAGUIDECONTEXT MyHandle;
  1947.  
  1948.     switch ( code )
  1949.     {
  1950.         /* Cursor hoch (Listview hoch)                            */
  1951.         case 76:
  1952.             /* sollte überhaupt ein Eintrag aktiv sein        */
  1953.             if( currentvdb )
  1954.             {
  1955.                 /* kucken wir, welche Nummer der hat            */
  1956.                 i = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  1957.                 /* senken die Nummer um 1 und                        */
  1958.                 i--;
  1959.                 /* sollten wir noch nicht ganz oben sein        */
  1960.                 if(i >= 0)
  1961.                 {
  1962.                     /* haben wir einen neuen aktuellen Eintr.    */
  1963.                     currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, i);    
  1964.                     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1965.                     /* ab damit ins Feld unter der Liste        */
  1966.                     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1967.                 }
  1968.             }
  1969.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  1970.             {
  1971.                 /* nein, dann selektiere den ersten Eintrag    */
  1972.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, 0);
  1973.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1974.                 /* aktiviere alle Gadgets                            */
  1975.                 checkonoff();
  1976.                 /* und setz den Disknamen ins String-Gadget    */
  1977.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1978.             }
  1979.             break;
  1980.  
  1981.         /* Cursor hoch (Listview hoch)                            */
  1982.         case 77:
  1983.             /* sollte überhaupt ein Eintrag aktiv sein        */
  1984.             if( currentvdb )
  1985.             {
  1986.                 /* kucken wir, welche Nummer der hat            */
  1987.                 i = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  1988.                 /* erhöhen die Nummer um 1 und                    */
  1989.                 i++;
  1990.                 /* sollten wir noch nicht ganz unten sein,    */
  1991.                 if(i < gt_GetListNumEntries( &vdblist ))
  1992.                 {
  1993.                     /* haben wir einen neuen aktuellen Eintr.    */
  1994.                     currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, i);    
  1995.                     /* ab damit ins Feld unter der Liste        */
  1996.                     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1997.                     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1998.                 }
  1999.             }
  2000.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  2001.             {
  2002.                 /* nein, dann selektiere den ersten Eintrag    */
  2003.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, gt_GetListNumEntries( &vdblist )-1 );
  2004.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  2005.                 /* aktiviere alle Gadgets                            */
  2006.                 checkonoff();
  2007.                 /* und setz den Disknamen ins String-Gadget    */
  2008.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2009.             }
  2010.             break;
  2011.  
  2012.         /* Help-Taste gedrückt                                        */
  2013.         case 95:
  2014.             /* Ist die AmigaGuide Library geöffnet + OS 3.x    */
  2015.             if( AmigaGuideBase != NULL )
  2016.             {
  2017.                 /* Legen wir die Guide-Datei fest                */
  2018.                 sync.nag_Name    = "T_Bestellen.guide";
  2019.  
  2020.                 /* steht der Mauszeiger über keinem Gadget,    */
  2021.                 if(gd == NULL)
  2022.                     /* den defaultmäßigen Node setzen            */
  2023.                     sync.nag_Node    = "Window";
  2024.                 /* steht der Mauszeiger über einem Gadget,    */
  2025.                 else
  2026.                     /* wird dar passende Node gesetzt            */
  2027.                     sync.nag_Node = AG_ID[gd->GadgetID];
  2028.  
  2029.                 /* Gut, öffnen wir die Guide Datei                */
  2030.                 MyHandle = OpenAmigaGuide( &sync, NULL );
  2031.  
  2032.                 /* und schließen sie, wenn's öffnen klappte    */
  2033.                 if(MyHandle)
  2034.                     CloseAmigaGuide( MyHandle);
  2035.  
  2036.             }
  2037.             /* Ist die AmigaGuide Library nicht zu öffnen,    */
  2038.             else
  2039.             {
  2040.                 /* gibts ne Message, daß ohne AmigaGuide nix    */
  2041.                 /* los ist mit der OnlineHilfe                    */
  2042.                 es.es_StructSize    = sizeof(struct EasyStruct);
  2043.                 es.es_Flags            = 0;
  2044.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  2045.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText3];
  2046.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  2047.  
  2048.                 EasyRequest(BestellenWnd, &es, NULL);
  2049.             }
  2050.             break;
  2051.  
  2052.         /* Sonstige Tasten jucken mich derzeit nicht            */
  2053.         default:
  2054.             break;
  2055.     }
  2056. }
  2057.  
  2058. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  2059. void Abfrage_Menuhelp( UWORD code)
  2060. {
  2061.     /* Ein paar Sachen für einen AmigaGuide aufruf            */
  2062.     struct NewAmigaGuide sync = {NULL};
  2063.  
  2064.     AMIGAGUIDECONTEXT MyHandle;
  2065.  
  2066.     /* Ist die AmigaGuide Library geöffnet + OS 3.x            */
  2067.     if( AmigaGuideBase != NULL )
  2068.     {
  2069.         /* Legen wir die Guide-Datei fest                        */
  2070.         sync.nag_Name    = "T_Bestellen.guide";
  2071.  
  2072.         /* steht der Mauszeiger über einem Menüpunkt?        */
  2073.         switch(code)
  2074.         {
  2075.             /* HELP beim Menü-Punkt Öffnen Adressen            */
  2076.             case 0:
  2077.                 sync.nag_Node    = "Menu_OPA";
  2078.                 break;
  2079.             /* HELP beim Menü-Punkt Öffnen Diskliste            */
  2080.             case 2048:
  2081.                 sync.nag_Node    = "Menu_OPB";
  2082.                 break;
  2083.             /* HELP beim Menü-Punkt Speichern Adressen        */
  2084.             case 32:
  2085.                 sync.nag_Node    = "Menu_SPA";
  2086.                 break;
  2087.             /* HELP beim Menü-Punkt Speichern Diskliste        */
  2088.             case 2080:
  2089.                 sync.nag_Node    = "Menu_SPB";
  2090.                 break;
  2091.             /* HELP beim Menü-Punkt Speichern als ... Adres.*/
  2092.             case 64:
  2093.                 sync.nag_Node    = "Menu_SAA";
  2094.                 break;
  2095.             /* HELP beim Menü-Punkt Speichern als... Diskl.    */
  2096.             case 2112:
  2097.                 sync.nag_Node    = "Menu_SAB";
  2098.                 break;
  2099.             /* HELP beim Menü-Punkt Drucken                        */
  2100.             case 63584:
  2101.                 sync.nag_Node    = "Menu_Dru";
  2102.                 break;
  2103.             /* HELP beim Menü-Punkt Über T_Bestellen ...        */
  2104.             case 63648:
  2105.                 sync.nag_Node    = "Menu_Inf";
  2106.                 break;
  2107.             /* HELP beim Menü-Punkt Speichern Adressen        */
  2108.             case 63712:
  2109.                 sync.nag_Node    = "Menu_HID";
  2110.                 break;
  2111.             /* HELP beim Menü-Punkt Beenden                        */
  2112.             case 63744:
  2113.                 sync.nag_Node    = "Menu_End";
  2114.                 break;
  2115.             /* HELP außerhalb des Menüs, oder über Trennb.    */
  2116.             default:
  2117.                 sync.nag_Node    = "Window";
  2118.                 break;
  2119.         }
  2120.  
  2121.         /* Gut, öffnen wir die Guide Datei                        */
  2122.         MyHandle = OpenAmigaGuide( &sync, NULL );
  2123.  
  2124.         /* und schließen sie, wenn's öffnen klappte            */
  2125.         if(MyHandle)
  2126.             CloseAmigaGuide( MyHandle);
  2127.  
  2128.     }
  2129.     /* Ist die AmigaGuide Library nicht zu öffnen,            */
  2130.     else
  2131.     {
  2132.         /* gibts ne Message, daß ohne AmigaGuide nix            */
  2133.         /* los ist mit der OnlineHilfe                            */
  2134.         es.es_StructSize    = sizeof(struct EasyStruct);
  2135.         es.es_Flags            = 0;
  2136.         es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  2137.         es.es_TextFormat    = AppStrings[MSG_ErrorReqText3];
  2138.         es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  2139.  
  2140.         EasyRequest(BestellenWnd, &es, NULL);
  2141.     }
  2142. }
  2143.  
  2144. /* Verarbeiten der Commodity-Botschaften                        */
  2145. BOOL Cx_Message( CxMsg *msg )
  2146. {
  2147.     ULONG msgid, msgtype;
  2148.     BOOL terminated = FALSE;
  2149.     /* Message ID ermitteln                                            */
  2150.     msgid = CxMsgID(msg);
  2151.     /* Ebenso den Typ                                                    */
  2152.     msgtype = CxMsgType(msg);
  2153.     /* Eine Botschaft sollte auch beantwortet werden        */
  2154.     ReplyMsg((struct Message *)msg);
  2155.     /* Messagetyp auswerten                                            */
  2156.     switch(msgtype)
  2157.     {
  2158.         /* Benutzerdefinierte Ereignisse                            */
  2159.         case CXM_IEVENT:
  2160.             switch( msgid )
  2161.             {
  2162.                 /* HotKey wurde betätigt                            */
  2163.                 case EVT_HOTKEY:
  2164.                     if( CX_Popup )
  2165.                         WindowToFront( BestellenWnd );
  2166.                     else
  2167.                     {
  2168.                         OpenBestellenWindow();
  2169.                         Winfuell();
  2170.                         if( currentvdb )
  2171.                         {
  2172.                             gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, ListPos);
  2173.                             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2174.                         }
  2175.                     }
  2176.                     break;
  2177.                 /* eigentlich wird sonst niemand erwartet        */
  2178.                 default:
  2179.                     break;
  2180.             }
  2181.             break;
  2182.         /* Kommando, bekannt aus Exchange                        */
  2183.         case CXM_COMMAND:
  2184.             switch( msgid )
  2185.             {
  2186.                 /* Commodity schlafen schicken                    */
  2187.                 case CXCMD_DISABLE:
  2188.                     ActivateCxObj(broker, 0L);
  2189.                     break;
  2190.                 /* und wieder aufwecken                                */
  2191.                 case CXCMD_ENABLE:
  2192.                     ActivateCxObj(broker, 1L);
  2193.                     break;
  2194.                 /* Keine Lust mehr? Beendet das Programm        */
  2195.                 case CXCMD_KILL:
  2196.                     terminated = TRUE;
  2197.                     break;
  2198.                 /* Programm wurde nochmal gestartet                */
  2199.                 /* Fenster öffnen                                        */
  2200.                 case CXCMD_UNIQUE:
  2201.                 case CXCMD_APPEAR:
  2202.                     if( CX_Popup )
  2203.                         WindowToFront( BestellenWnd );
  2204.                     else
  2205.                     {
  2206.                         OpenBestellenWindow();
  2207.                         Winfuell();
  2208.                         if( currentvdb )
  2209.                         {
  2210.                             gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, ListPos);
  2211.                             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2212.                         }
  2213.                     }
  2214.                     break;
  2215.                 /* Fenster verbergen                                    */
  2216.                 case CXCMD_DISAPPEAR:
  2217.                     if( CX_Popup )
  2218.                         CloseBestellenWindow();
  2219.                     break;
  2220.                 default:
  2221.                     break;
  2222.             }
  2223.             break;
  2224.         default:
  2225.             break;
  2226.     }
  2227.     return terminated;
  2228. }
  2229.  
  2230.  
  2231. /* Lokalisierte Texte einlesen (wenn vorhanden)                */
  2232. void LocaleLesen()
  2233. {
  2234.     if (LocaleBase) {
  2235.         struct    Catalog    *catalog = OpenCatalog (NULL,"T_Bestellen.catalog",OC_BuiltInLanguage,MSG_Language,TAG_DONE) ;
  2236.         if (catalog) {
  2237.             UBYTE    n ;
  2238.             for (n=0 ; n<=MSG_Max ; n++)
  2239.                 AppStrings[n] = GetCatalogStr (catalog,n,AppStrings[n]) ;
  2240.             CloseCatalog (catalog) ;
  2241.         }
  2242.     }
  2243.     /* Hotkey-Vermerk an den Fenstertitel anhängen            */
  2244.     strcpy(WinTitel, AppStrings[MSG_WindowName]);
  2245.     strcat(WinTitel, CX_Popkey);
  2246.     strcat(WinTitel, ">");
  2247.  
  2248.     /* MenuTexte übernehmen                                            */
  2249.     BestellenNewMenu[0].nm_Label = AppStrings[MSG_MenuText1];
  2250.     BestellenNewMenu[1].nm_Label = AppStrings[MSG_MenuText2];
  2251.     BestellenNewMenu[2].nm_Label = AppStrings[MSG_MenuText2a];
  2252.     BestellenNewMenu[3].nm_Label = AppStrings[MSG_MenuText2b];
  2253.     BestellenNewMenu[4].nm_Label = AppStrings[MSG_MenuText3];
  2254.     BestellenNewMenu[5].nm_Label = AppStrings[MSG_MenuText2a];
  2255.     BestellenNewMenu[6].nm_Label = AppStrings[MSG_MenuText2b];
  2256.     BestellenNewMenu[7].nm_Label = AppStrings[MSG_MenuText4];
  2257.     BestellenNewMenu[8].nm_Label = AppStrings[MSG_MenuText2a];
  2258.     BestellenNewMenu[9].nm_Label = AppStrings[MSG_MenuText2b];
  2259.     BestellenNewMenu[10].nm_Label = AppStrings[MSG_MenuText5];
  2260.     BestellenNewMenu[12].nm_Label = AppStrings[MSG_MenuText6];
  2261.     BestellenNewMenu[14].nm_Label = AppStrings[MSG_MenuText7];
  2262.     BestellenNewMenu[15].nm_Label = AppStrings[MSG_MenuText8];
  2263.  
  2264.     /* Menu-ShortCuts übernehmen                                    */
  2265.     BestellenNewMenu[2].nm_CommKey = AppStrings[MSG_MenuKey2];
  2266.     BestellenNewMenu[3].nm_CommKey = AppStrings[MSG_MenuKey2b];
  2267.     BestellenNewMenu[5].nm_CommKey = AppStrings[MSG_MenuKey3];
  2268.     BestellenNewMenu[6].nm_CommKey = AppStrings[MSG_MenuKey3b];
  2269.     BestellenNewMenu[8].nm_CommKey = AppStrings[MSG_MenuKey4];
  2270.     BestellenNewMenu[9].nm_CommKey = AppStrings[MSG_MenuKey4b];
  2271.     BestellenNewMenu[10].nm_CommKey = AppStrings[MSG_MenuKey5];
  2272.     BestellenNewMenu[12].nm_CommKey = AppStrings[MSG_MenuKey6];
  2273.     BestellenNewMenu[14].nm_CommKey = AppStrings[MSG_MenuKey7];
  2274.     BestellenNewMenu[15].nm_CommKey = AppStrings[MSG_MenuKey8];
  2275.  
  2276.     /* Gadget-Texte übernehmen                                        */
  2277.     BestellenNGad[0].ng_GadgetText = AppStrings[MSG_GadgetText1];
  2278.     BestellenNGad[1].ng_GadgetText = AppStrings[MSG_GadgetText2];
  2279.     BestellenNGad[2].ng_GadgetText = AppStrings[MSG_GadgetText3];
  2280.     BestellenNGad[4].ng_GadgetText = AppStrings[MSG_GadgetText5];
  2281.     BestellenNGad[5].ng_GadgetText = AppStrings[MSG_GadgetText6];
  2282.     BestellenNGad[6].ng_GadgetText = AppStrings[MSG_GadgetText7];
  2283.     BestellenNGad[7].ng_GadgetText = AppStrings[MSG_GadgetText8];
  2284.     BestellenNGad[8].ng_GadgetText = AppStrings[MSG_GadgetText9];
  2285.     BestellenNGad[9].ng_GadgetText = AppStrings[MSG_GadgetText10];
  2286.     BestellenNGad[10].ng_GadgetText = AppStrings[MSG_GadgetText11];
  2287.     BestellenNGad[11].ng_GadgetText = AppStrings[MSG_GadgetText12];
  2288.     BestellenNGad[12].ng_GadgetText = AppStrings[MSG_GadgetText13];
  2289.     BestellenNGad[14].ng_GadgetText = AppStrings[MSG_GadgetText15];
  2290.  
  2291.     /* IText (Infotexte auf dem Screen)                            */
  2292.     BestellenIText[0].IText = AppStrings[MSG_IText1];
  2293.     BestellenIText[1].IText = AppStrings[MSG_IText2];
  2294.  
  2295.     /* MX-Gadget (Versandarten-Gadget)                            */
  2296.     Gadget300Labels[0] = AppStrings[MSG_Versandart1];
  2297.     Gadget300Labels[1] = AppStrings[MSG_Versandart2];
  2298.     Gadget300Labels[2] = AppStrings[MSG_Versandart3];
  2299. }
  2300.  
  2301. /* IconToolTypes einlesen                                            */
  2302. void ToolTypesLesen(char *name)
  2303. {
  2304.     struct DiskObject        *diskobj;
  2305.     char *s;
  2306.  
  2307.     /* Icon.library geöffnet?                                        */
  2308.     if ( IconBase )
  2309.     {
  2310.         diskobj = GetDiskObject( name );
  2311.         if (diskobj)
  2312.         {
  2313.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"POSX"))
  2314.                 WinX = atoi(s);
  2315.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"POSY"))
  2316.                 WinY = atoi(s);
  2317.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"DISKFILE"))
  2318.                 strcpy(T_Remember, s);
  2319.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"ADDRFILE"))
  2320.                 strcpy(Einst_File, s);
  2321.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_PRIORITY"))
  2322.                 CX_Priority = atoi(s);
  2323.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_POPUP"))
  2324.                 if(MatchToolValue(s,"NO"))
  2325.                     CX_Popup = FALSE;
  2326.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_POPKEY"))
  2327.                 strcpy(CX_Popkey, s);
  2328.             FreeDiskObject (diskobj);
  2329.         }        
  2330.     }
  2331. }
  2332.  
  2333. /* Einrichten des Programms als Commodity                        */
  2334. void StartCom()
  2335. {
  2336.     translate = NULL;
  2337.     if ( CxBase )
  2338.     {
  2339.         /* NewBroker Structur füllen:                                */
  2340.         /* Version der NewBroker strukt. (immer NB_Version)*/
  2341.         newbroker.nb_Version = NB_VERSION;
  2342.         /* Programmname, erscheint dann in der Exchange-L.    */
  2343.         newbroker.nb_Name = (char *)AppStrings[MSG_MXName];
  2344.         /* Programmbezeich., erste Zeile Exchange B.            */
  2345.         newbroker.nb_Title = (char *)AppStrings[MSG_MXInfoName];
  2346.         /* Programmbeschreibung, zweite Zeile Exchange B.    */
  2347.         newbroker.nb_Descr = (char *)AppStrings[MSG_MXInfoText];
  2348.         /* Doppelten Start des PGMs verhindern und            */
  2349.         /* Nachricht an das Laufende Programm, beim Versuch*/
  2350.         newbroker.nb_Unique = NBU_UNIQUE | NBU_NOTIFY;
  2351.         /* Fenster ist vorhanden!                                    */
  2352.         newbroker.nb_Flags = COF_SHOW_HIDE;
  2353.         /* Priorität des Commodities (per ToolType wählb.)    */
  2354.         newbroker.nb_Pri = CX_Priority;
  2355.         /* MsgPort, der muß aber erst eingerichtet werden    */
  2356.         newbroker.nb_Port = CreateMsgPort();
  2357.         /* Der Rest ist für künftige Funktionen reserviert    */
  2358.         newbroker.nb_ReservedChannel = NULL;
  2359.  
  2360.         /* Broker an Commodity-Lib zur Anmeldung übergeben    */
  2361.         if( broker = CxBroker(&newbroker,NULL) )
  2362.         {
  2363.             /* Hotkey zu Filterobjekt verarbeiten                */
  2364.             if (filter = CxFilter(CX_Popkey))
  2365.             {
  2366.                 /* HotKey Filter an broker anhängen                */
  2367.                 AttachCxObj(broker, filter);
  2368.                 if (sender = CxSender(newbroker.nb_Port, EVT_HOTKEY))
  2369.                 {
  2370.                     AttachCxObj(filter,sender);
  2371.                     if (translate = CxTranslate(NULL))
  2372.                     {
  2373.                         AttachCxObj(filter,translate);
  2374.                         if(!CxObjError(filter))
  2375.                         {
  2376.                             /* Broker aktivieren                        */
  2377.                             ActivateCxObj(broker, 1L);
  2378.                             /* Signal-Bit merken, für Abfrage    */
  2379.                             cxsigflag = 1L << newbroker.nb_Port->mp_SigBit;
  2380.                         }
  2381.                     }
  2382.                 }
  2383.             }
  2384.         }
  2385.     }
  2386. }
  2387.  
  2388. /* Einrichten der Notify-Struktur                                */
  2389. void NotifyStarten()
  2390. {
  2391.     if(nr = (struct NotifyRequest*)AllocVec
  2392.     (sizeof(struct NotifyRequest),MEMF_PUBLIC|MEMF_CLEAR))
  2393.     {
  2394.         if(nmp = CreateMsgPort())
  2395.         {
  2396.             nr->nr_Name        = T_Remember;
  2397.             nr->nr_Flags    = NRF_SEND_MESSAGE | NRF_WAIT_REPLY | NRF_NOTIFY_INITIAL;
  2398.             nr->nr_stuff.nr_Msg.nr_Port = nmp;
  2399.  
  2400.             StartNotify(nr);
  2401.         }
  2402.     }
  2403. }
  2404.  
  2405. /* Hauptprogramm                                                        */
  2406. int main( int argc, char *argv[] )
  2407. {
  2408.     /* Hatt das öffnen der Libraries hingehauen?                */
  2409.     if( OpenAll() == TRUE )
  2410.     {
  2411.         struct    VDBnode    *n;
  2412.         struct    IntuiMessage    *imsg;
  2413.         struct    Gadget    *gad;
  2414.         struct    Gadget    *gd = NULL;
  2415.         ULONG        imsgClass;
  2416.         UWORD        imsgCode;
  2417.         BOOL        Done    = FALSE;
  2418.         CxMsg        *msg;
  2419.  
  2420.         /* Einlesen der ToolTypes (für Benutzereinstell.)    */
  2421.         /* In argv[0] steht übrigens der Programmname        */
  2422.         ToolTypesLesen(argv[0]);
  2423.  
  2424.         /* Einlesen der Locale-Daten (für andere Sprachen)    */
  2425.         LocaleLesen();
  2426.  
  2427.         /* Als Commodity einrichten                                */
  2428.         StartCom();
  2429.         if (!translate)
  2430.             exit(0);
  2431.  
  2432.         /* Einstellungen lesen                                        */
  2433.         EinstLesen();
  2434.  
  2435.         /* Daten lesen                                                    */
  2436.         DatenLesen();
  2437.  
  2438.         /* Notify einrichten und starten                            */
  2439.         NotifyStarten();
  2440.  
  2441.         /* Bildschirm vorbereiten                                    */
  2442.         SetupScreen();
  2443.         /* Fenster öffnen, wenn per ToolTypes so gewählt    */
  2444.         if ( CX_Popup )
  2445.         {
  2446.             OpenBestellenWindow();
  2447.             /* Window mit Voreinstellungen füllen                */
  2448.             Winfuell();
  2449.         }
  2450.  
  2451.         /* Hauptschleife                                                */
  2452.         while( !Done )
  2453.         {
  2454.             /* Auf IntuiMassage warten                                */
  2455.             Wait( cxsigflag | wndsigflag | 1L << nmp->mp_SigBit );
  2456.  
  2457.             /* und Auswerten (Commodity)                            */
  2458.             if (cxsigflag)
  2459.             {
  2460.                 while(msg = (CxMsg *)GetMsg(newbroker.nb_Port))
  2461.                 {
  2462.                     Done = Cx_Message(msg);
  2463.                 }
  2464.             }
  2465.  
  2466.             /* Auswertung von Disk-Dateiveränderungen:        */
  2467.             if( 1L << nmp->mp_SigBit )
  2468.             {
  2469.                 while( nm = (struct NotifyMessage*)GetMsg(nmp))
  2470.                 {
  2471.                     switch(nm->nm_Class)
  2472.                     {
  2473.                         case NOTIFY_CLASS:
  2474.                             /* Liste abhängen                            */
  2475.                             if( CX_Popup )
  2476.                                 gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, (struct List *) ~0 );
  2477.                             /* Alte Liste löschen                    */
  2478.                             while( ( n = (struct VDBnode *) RemHead( &vdblist ) ) )
  2479.                             {
  2480.                                 FreeVec(n);
  2481.                             }
  2482.                             /* Gut, schreibe die Bestellung        */
  2483.                             DatenLesen();
  2484.                             /* Liste wieder dranhängen                */
  2485.                             if( CX_Popup )
  2486.                             {
  2487.                                 gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, &vdblist );
  2488.                                 /* Bearbeitungsgadget löschen        */
  2489.                                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, "");
  2490.                                 /* Gadgets ausblenden                */
  2491.                                 checkonoff();
  2492.                             }
  2493.                             break;
  2494.                         default:
  2495.                             break;
  2496.                     }
  2497.                     ReplyMsg(&nm->nm_ExecMessage);
  2498.                 }
  2499.             }
  2500.  
  2501.             /* Nachricht vom Fenster                                */ 
  2502.             while((CX_Popup) && (imsg = GT_GetIMsg(BestellenWnd->UserPort)))
  2503.             {
  2504.                 imsgClass        = imsg->Class;
  2505.                 imsgCode            = imsg->Code;
  2506.                 gad = (struct Gadget *)imsg->IAddress;
  2507.  
  2508.                 /* Jede empfangen Nachricht bestätigen            */
  2509.                 GT_ReplyIMsg(imsg);
  2510.  
  2511.                 switch( imsgClass )
  2512.                 {
  2513.                     /* Windowschließsymbol gedrückt                */
  2514.                     case IDCMP_CLOSEWINDOW:
  2515.                         CloseBestellenWindow();
  2516.                         break;
  2517.  
  2518.                     /* Gadget gedrückt                                */
  2519.                     case IDCMP_GADGETUP:
  2520.                     case IDCMP_GADGETDOWN:
  2521.                         Done = Abfrage_Gadgetup(gad, imsgCode);
  2522.                         break;
  2523.  
  2524.                     /* Menupunkt ausgewählt                            */
  2525.                     case IDCMP_MENUPICK:
  2526.                         Done = Abfrage_Menuepick(imsgCode);
  2527.                         break;
  2528.  
  2529.                     /* gewähnliche Taste gedrückt                    */
  2530.                     case IDCMP_VANILLAKEY:
  2531.                         Done = Abfrage_Vanillakey( gad, imsgCode);
  2532.                         break;
  2533.  
  2534.                     /* Mauszeiger ruht kurze Zeit über            */
  2535.                     /* einem Gadget => Gadget merken                */
  2536.                     case IDCMP_GADGETHELP:
  2537.                         if( imsg->IAddress == (APTR) BestellenWnd ) 
  2538.                             gd = NULL;
  2539.                         else
  2540.                             gd = gad;
  2541.                         break;
  2542.  
  2543.                     /* Während der Menüauswahl wurde die        */
  2544.                     /* Help-Taste gedrückt                            */
  2545.                     case IDCMP_MENUHELP:
  2546.                         Abfrage_Menuhelp( imsgCode);
  2547.                         break;
  2548.  
  2549.                     /* Steuertaste gedrückt                            */
  2550.                     case IDCMP_RAWKEY:
  2551.                         Abfrage_Rawkey(gad,imsgCode,gd);
  2552.                         break;
  2553.  
  2554.                     /* Irgend was anderes, ignorieren            */
  2555.                     default:
  2556.                         break;
  2557.                 }
  2558.             }
  2559.         }
  2560.  
  2561.         /* Fenster und Bilschirm schließen                        */
  2562.         CloseBestellenWindow();
  2563.         CloseDownScreen();
  2564.  
  2565.         /* Notifycation wieder beenden                            */
  2566.         if( nr )
  2567.             EndNotify(nr);
  2568.  
  2569.         /* Messageport wieder dicht machen                        */
  2570.         if( nmp )
  2571.             DeleteMsgPort(nmp);
  2572.  
  2573.         /* Vector auch wieder freigeben                            */
  2574.         FreeVec(nr);
  2575.  
  2576.         /* Einstellungen speichern                                    */
  2577.         EinstSchreiben();
  2578.  
  2579.         /* Daten speichern und freigeben                            */
  2580.         DatenSchreiben(&vdblist);
  2581.         while( ( n = (struct VDBnode *) RemHead( &vdblist ) ) )
  2582.         {
  2583.             FreeVec(n);
  2584.         }
  2585.         /* Als Commodity abmelden                                    */
  2586.         if ( broker )
  2587.             DeleteCxObj( broker );
  2588.         /* Noch übrige Meldungen abarbeiten                        */
  2589.         while(msg = (CxMsg *)GetMsg(newbroker.nb_Port))
  2590.             ReplyMsg((struct Message *)msg);
  2591.         /* Commodity-Port freigeben                                */
  2592.         if (newbroker.nb_Port)
  2593.             DeletePort(newbroker.nb_Port);
  2594.     }
  2595.     /* Die Librareis konnten nicht (alle) geöffnet werden    */
  2596.     else
  2597.     {
  2598.         /* Nachricht an den User, daß da was nicht stimmt    */
  2599.         printf(AppStrings[MSG_OSError]);
  2600.     }
  2601.     /* geöffnete Libraries wieder schließen                    */
  2602.     CloseAll();
  2603.  
  2604.     /* 0 zurückgeben = alles glattgelaufen                        */
  2605.     return(0);
  2606. }
  2607.